home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Language/OS - Multiplatform Resource Library
/
LANGUAGE OS.iso
/
lisp
/
kcl
/
akcl
/
kcl.lha
/
doc
/
prindoc.out
< prev
next >
Wrap
Text File
|
1986-07-17
|
348KB
|
6,595 lines
Kyoto Common Lisp Dictionary
Version 01.25
17 JUL 86
by
Taiichi Yuasa
Masami Hagiya
Research Institute for Mathematical Sciences
Kyoto University
Kyoto 606, Japan
(C) Copyright Taiichi Yuasa and Masami Hagiya, 1986
Preface
This Dictionary was produced from the on-line documentation of
Kyoto Common Lisp (KCL for short). Its primary purpose is to
maintain the KCL on-line documentation, but it is available to
the public as a reference material. The contents of this
Dictionary are updated periodically as the on-line documentation
is revised.
This Dictionary lists all special form names, all built-in macro
names, all built-in function names, all built-in variable names,
all built-in constant names, and some type names, in alphabetic
order, along with the documentation strings associated with these
symbols. Some useful system internals are also listed in
alphabetic order, after the description of ZEROP. A key index to
the built-in symbols are provided at the end. There, keys are
listed in alphabetic order, and for each key, the symbols indexed
with that key are listed in alphabetic order. The number after
each symbol is the page of this Dictionary where the
documentation of the symbol is found. A 'key' of a symbol SYMBOL
is a substring of the print name of SYMBOL consisting of two or
more alphanumeric characters. For example, the symbol
WITH-INPUT-FROM-STRING has four keys
WITH, INPUT, FORM, and STRING
Some phrases in the documentation strings came from Steele's
manual and some from Spice code. But almost all sentences are
tuned for KCL.
If you find any error in the documentation strings, please report
to us at the following network addresses. Thank you for your
cooperation.
11 MAR 86
Taiichi Yuasa
"kddlab!kurims!yuasa"@Shasta.arpa
yuasa@kurims.junet
Masami Hagiya
"kddlab!kurims!hagiya"@Shasta.arpa
hagiya@kurims.junetKCL Dictionary Page 1
------------------------------------------------------------------------------
* [Function]
Args: (&rest numbers)
Returns the product of its arguments. With no args, returns 1.
------------------------------------------------------------------------------
* [Variable]
Holds the value of the most recent top-level form.
------------------------------------------------------------------------------
** [Variable]
Gets the previous value of * when KCL evaluates a top-level form.
------------------------------------------------------------------------------
*** [Variable]
Gets the previous value of ** when KCL evaluates a top-level form.
------------------------------------------------------------------------------
+ [Function]
Args: (&rest numbers)
Returns the sum of its arguments. With no args, returns 0.
------------------------------------------------------------------------------
+ [Variable]
Holds the most recent top-level form.
------------------------------------------------------------------------------
++ [Variable]
Gets the previous value of + when KCL evaluates a top-level form.
------------------------------------------------------------------------------
+++ [Variable]
Gets the previous value of ++ when KCL evaluates a top-level form.
------------------------------------------------------------------------------
- [Function]
Args: (number &rest more-numbers)
Subtracts the second NUMBER and all subsequent NUMBERs from the first NUMBER.
With one arg, negates it.
------------------------------------------------------------------------------
- [Variable]
Holds the top-level form that KCL is currently evaluating.
------------------------------------------------------------------------------
/ [Function]
Args: (number &rest more-numbers)
Divides the first NUMBER by each of the subsequent NUMBERS, in turn.
With one arg, returns reciprocal.
------------------------------------------------------------------------------
/ [Variable]
Holds a list of all the values of the most recent top-level form.
------------------------------------------------------------------------------
// [Variable]
Gets the previous value of / when KCL evaluates a top-level form.
------------------------------------------------------------------------------
KCL Dictionary Page 2
------------------------------------------------------------------------------
/// [Variable]
Gets the previous value of // when KCL evaluates a top-level form.
------------------------------------------------------------------------------
/= [Function]
Args: (number &rest more-numbers)
Returns T if no two of its arguments are numerically equal; NIL otherwise.
------------------------------------------------------------------------------
1+ [Function]
Args: (number)
Returns NUMBER + 1.
------------------------------------------------------------------------------
1- [Function]
Args: (number)
Returns NUMBER - 1.
------------------------------------------------------------------------------
< [Function]
Args: (number &rest more-numbers)
Returns T if its arguments are in strictly increasing order; NIL otherwise.
------------------------------------------------------------------------------
<= [Function]
Args: (number &rest more-numbers)
Returns T if arguments are in strictly non-decreasing order; NIL otherwise.
------------------------------------------------------------------------------
= [Function]
Args: (number &rest more-numbers)
Returns T if all of its arguments are numerically equal; NIL otherwise.
------------------------------------------------------------------------------
> [Function]
Args: (number &rest more-numbers)
Returns T if its arguments are in strictly decreasing order; NIL otherwise.
------------------------------------------------------------------------------
>= [Function]
Args: (number &rest more-numbers)
Returns T if arguments are in strictly non-increasing order; NIL otherwise.
------------------------------------------------------------------------------
ABS [Function]
Args: (number)
Returns the absolute value of the number.
------------------------------------------------------------------------------
ACONS [Function]
Args: (key datum alist)
Constructs a new alist by adding the pair (KEY . DATUM) to ALIST.
------------------------------------------------------------------------------
ACOS [Function]
Args: (number)
Returns the arc cosine of NUMBER.
------------------------------------------------------------------------------
KCL Dictionary Page 3
------------------------------------------------------------------------------
ACOSH [Function]
Args: (number)
Returns the hyperbolic arc cosine of NUMBER.
------------------------------------------------------------------------------
ADJOIN [Function]
Args: (item list &key (test #'eql) test-not (key #'identity))
Adds ITEM to LIST unless it is already a member.
------------------------------------------------------------------------------
ADJUST-ARRAY [Function]
Args: (array dimensions
&key (element-type (array-element-type array))
initial-element (initial-contents nil) (fill-pointer nil)
(displaced-to nil) (displaced-index-offset 0))
Adjusts the dimensions of ARRAY to the given DIMENSIONS. The default for
INITIAL-ELEMENT depends on ELEMENT-TYPE.
------------------------------------------------------------------------------
ADJUSTABLE-ARRAY-P [Function]
Args: (array)
Returns T if ARRAY is adjustable; NIL otherwise.
------------------------------------------------------------------------------
ALLOCATE [Function]
Args: (type number &optional (really-allocate nil))
KCL specific: Sets the maximum number of pages for the type class of the
KCL implementation type TYPE to NUMBER. If REALLY-ALLOCATE is given a
non-NIL value, then the specified number of pages will be allocated
immediately.
------------------------------------------------------------------------------
ALLOCATE-CONTIGUOUS-PAGES [Function]
Args: (number &optional (really-allocate nil))
KCL specific: Sets the maximum number of pages for contiguous blocks to
NUMBER. If REALLY-ALLOCATE is given a non-NIL value, then the specified
number of pages will be allocated immediately.
------------------------------------------------------------------------------
ALLOCATE-RELOCATABLE-PAGES [Function]
Args: (number)
KCL specific: Sets the maximum number of pages for relocatable blocks to
NUMBER.
------------------------------------------------------------------------------
ALLOCATED-CONTIGUOUS-PAGES [Function]
Args: ()
KCL specific: Returns the number of pages currently allocated for contiguous
blocks.
------------------------------------------------------------------------------
ALLOCATED-PAGES [Function]
Args: (type)
KCL specific: Returns the number of pages currently allocated for the type
class of the KCL implementation type TYPE.
------------------------------------------------------------------------------
KCL Dictionary Page 4
------------------------------------------------------------------------------
ALLOCATED-RELOCATABLE-PAGES [Function]
Args: ()
KCL specific: Returns the number of pages currently allocated for relocatable
blocks.
------------------------------------------------------------------------------
ALPHA-CHAR-P [Function]
Args: (char)
Returns T if CHAR is an alphabetic character, A-Z or a-z; NIL otherwise.
------------------------------------------------------------------------------
ALPHANUMERICP [Function]
Args: (char)
Returns T if CHAR is either numeric or alphabetic; NIL otherwise.
------------------------------------------------------------------------------
AND [Macro]
Syntax: (and {form}*)
Evaluates FORMs in order from left to right. If any FORM evaluates to NIL,
quits and returns NIL. Else, returns the value(s) of the last FORM.
------------------------------------------------------------------------------
APPEND [Function]
Args: (&rest lists)
Constructs a new list by concatenating its arguments.
------------------------------------------------------------------------------
APPLY [Function]
Args: (function arg &rest more-args)
Applies FUNCTION to a list of arguments produced by evaluating ARGs. The
arguments consist of the last ARG appended to the end of a list of all the
other ARGs.
------------------------------------------------------------------------------
APPLYHOOK [Function]
Args: (function args evalhookfn applyhookfn &optional (env nil))
Applies FUNCTION to ARGS, with *EVALHOOK* bound to EVALHOOKFN and with
*APPLYHOOK* bound to APPLYHOOKFN. Ignores the hook function once, for the
top-level application of FUNCTION to ARGS.
------------------------------------------------------------------------------
*APPLYHOOK* [Variable]
Used to substitute another function for the implicit APPLY normally done
within EVAL. If *APPLYHOOK* is not NIL, its value must be a function
which takes three arguments: a function to be applied, a list of arguments,
and an environment. This function does the application instead of APPLY.
------------------------------------------------------------------------------
APROPOS [Function]
Args: (string &optional (package nil))
Prints out all symbols (in the specified package, if PACKAGE is non-NIL)
whose print-names contain STRING as substring.
------------------------------------------------------------------------------
APROPOS-LIST [Function]
Args: (string &optional (package nil))
Returns, as a list, all symbols (in the specified package, if PACKAGE is
non-NIL) whose print-names contain STRING as substring.
------------------------------------------------------------------------------
KCL Dictionary Page 5
------------------------------------------------------------------------------
AREF [Function]
Args: (array &rest subscripts)
Returns the element of ARRAY specified by SUBSCRIPTS.
------------------------------------------------------------------------------
ARRAY [Type]
An array is an object with components arranged according to Cartesian
coordinate system. Vectors are kinds of arrays. Other arrays are called
general arrays and are denoted as
#?a( ... ) or #?A( ... )
where '?' is actually the rank of the array.
Some arrays may be displaced to another array, may have a fill pointer, or
may be adjusted its size. Other arrays are called simple arrays.
------------------------------------------------------------------------------
ARRAY-DIMENSION [Function]
Args: (array axis-number)
Returns the length of AXIS-NUMBER of ARRAY.
------------------------------------------------------------------------------
ARRAY-DIMENSION-LIMIT [Constant]
The exclusive upper bound any given dimension of an array.
------------------------------------------------------------------------------
ARRAY-DIMENSIONS [Function]
Args: (array)
Returns a list whose elements are the dimensions of ARRAY
------------------------------------------------------------------------------
ARRAY-ELEMENT-TYPE [Function]
Args: (array)
Returns the type of the elements of ARRAY
------------------------------------------------------------------------------
ARRAY-HAS-FILL-POINTER-P [Function]
Args: (array)
Returns T if ARRAY has a fill pointer; NIL otherwise.
------------------------------------------------------------------------------
ARRAY-IN-BOUNDS-P [Function]
Args: (array &rest subscripts)
Returns T if SUBSCRIPTS are in bounds for the array ARRAY; NIL otherwise.
------------------------------------------------------------------------------
ARRAY-RANK [Function]
Args: (array)
Returns the number of dimensions of ARRAY.
------------------------------------------------------------------------------
ARRAY-RANK-LIMIT [Constant]
The exclusive upper bound on the rank of an array.
------------------------------------------------------------------------------
ARRAY-ROW-MAJOR-INDEX [Function]
Args: (array &rest subscripts)
Returns the index into ARRAY's data vector for SUBSCRIPTS.
------------------------------------------------------------------------------
KCL Dictionary Page 6
------------------------------------------------------------------------------
ARRAY-TOTAL-SIZE [Function]
Args: (array)
Returns the total number of elements in ARRAY.
------------------------------------------------------------------------------
ARRAY-TOTAL-SIZE-LIMIT [Constant]
The exclusive upper bound on the total number of elements in an array.
------------------------------------------------------------------------------
ARRAYP [Function]
Args: (x)
Returns T if X is an array; NIL otherwise.
------------------------------------------------------------------------------
ASH [Function]
Args: (integer count)
Shifts INTEGER left by COUNT places preserving sign. Minus COUNT shifts
right.
------------------------------------------------------------------------------
ASIN [Function]
Args: (number)
Returns the arc sine of NUMBER.
------------------------------------------------------------------------------
ASINH [Function]
Args: (number)
Returns the hyperbolic arc sine of NUMBER.
------------------------------------------------------------------------------
ASSERT [Macro]
Syntax: (assert test-form [({place}*) [string {arg}*]])
Signals an error if the value of TEST-FORM is NIL. STRING is an error message
string and ARGs are additional arguments.
------------------------------------------------------------------------------
ASSOC [Function]
Args: (item alist &key (test #'eql) test-not)
Returns the cons in ALIST whose car is equal to ITEM.
------------------------------------------------------------------------------
ASSOC-IF [Function]
Args: (test alist)
Returns the first cons in ALIST whose car satisfies TEST.
------------------------------------------------------------------------------
ASSOC-IF-NOT [Function]
Args: (test alist)
Returns the first cons in ALIST whose car does not satisfy TEST.
------------------------------------------------------------------------------
ATAN [Function]
Args: (x &optional y)
Returns the arc tangent of X (if Y is not supplied) or X/Y.
------------------------------------------------------------------------------
KCL Dictionary Page 7
------------------------------------------------------------------------------
ATANH [Function]
Args: (number)
Returns the hyperbolic arc tangent of NUMBER.
------------------------------------------------------------------------------
ATOM [Function]
Args: (x)
Returns T if X is not a cons; NIL otherwise.
------------------------------------------------------------------------------
BIGNUM [Type]
A bignum is an integer that is not a fixnum.
------------------------------------------------------------------------------
BIT [Function]
Args: (bit-array &rest subscripts)
Returns the bit from BIT-ARRAY at SUBSCRIPTS.
------------------------------------------------------------------------------
BIT-AND [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical AND on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-ANDC1 [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical ANDC1 on the elements of BIT-ARRAY1 and
BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-ANDC2 [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical ANDC2 on the elements of BIT-ARRAY1 and
BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-EQV [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical EQV on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-IOR [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical IOR on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 8
------------------------------------------------------------------------------
BIT-NAND [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical NAND on the elements of BIT-ARRAY1 and
BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-NOR [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical NOR on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-NOT [Function]
Args: (bit-array &optional (result-bit-array nil))
Performs a bit-wise logical NOT in the elements of BIT-ARRAY.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-ORC1 [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical ORC1 on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-ORC2 [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical ORC2 on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
BIT-VECTOR [Type]
A bit-vector is a vector of bits. A bit-vector is denoted by '#*' followed
by the constituent bits (0 or 1).
Some bit-vectors may be displaced to another bit-vectors, may have a fill
pointer, or may be adjusted its size. Other bit-vectors are called simple
bit-vectors.
------------------------------------------------------------------------------
BIT-VECTOR-P [Function]
Args: (x)
Returns T if X is a bit vector; NIL otherwise.
------------------------------------------------------------------------------
BIT-XOR [Function]
Args: (bit-array1 bit-array2 &optional (result-bit-array nil))
Performs a bit-wise logical XOR on the elements of BIT-ARRAY1 and BIT-ARRAY2.
Puts the results into a new bit array if RESULT-BIT-ARRAY is NIL, into
BIT-ARRAY1 if RESULT-BIT-ARRAY is T, or into RESULT-BIT-ARRAY otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 9
------------------------------------------------------------------------------
BLOCK [Special form]
Syntax: (block name {form}*)
The FORMs are evaluated in order, but it is possible to exit the block
using (RETURN-FROM name value). The RETURN-FROM must be lexically contained
within the block.
------------------------------------------------------------------------------
BOOLE [Function]
Args: (op integer1 integer2)
Returns an integer produced by performing the logical operation specified by
OP on the two integers. OP must be the value of one of the following
constants:
BOOLE-CLR BOOLE-C1 BOOLE-XOR BOOLE-ANDC1
BOOLE-SET BOOLE-C2 BOOLE-EQV BOOLE-ANDC2
BOOLE-1 BOOLE-AND BOOLE-NAND BOOLE-ORC1
BOOLE-2 BOOLE-IOR BOOLE-NOR BOOLE-ORC2
See the variable docs of these constants for their operations.
------------------------------------------------------------------------------
BOOLE-1 [Constant]
Makes BOOLE return INTEGER1.
------------------------------------------------------------------------------
BOOLE-2 [Constant]
Makes BOOLE return INTEGER2.
------------------------------------------------------------------------------
BOOLE-AND [Constant]
Makes BOOLE return LOGAND of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-ANDC1 [Constant]
Makes BOOLE return LOGANDC1 of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-ANDC2 [Constant]
Makes BOOLE return LOGANDC2 of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-C1 [Constant]
Makes BOOLE return the complement of INTEGER1.
------------------------------------------------------------------------------
BOOLE-C2 [Constant]
Makes BOOLE return the complement of INTEGER2.
------------------------------------------------------------------------------
BOOLE-CLR [Constant]
Makes BOOLE return 0.
------------------------------------------------------------------------------
BOOLE-EQV [Constant]
Makes BOOLE return LOGEQV of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-IOR [Constant]
Makes BOOLE return LOGIOR of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
KCL Dictionary Page 10
------------------------------------------------------------------------------
BOOLE-NAND [Constant]
Makes BOOLE return LOGNAND of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-NOR [Constant]
Makes BOOLE return LOGNOR of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-ORC1 [Constant]
Makes BOOLE return LOGORC1 of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-ORC2 [Constant]
Makes BOOLE return LOGORC2 of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOOLE-SET [Constant]
Makes BOOLE return -1.
------------------------------------------------------------------------------
BOOLE-XOR [Constant]
Makes BOOLE return LOGXOR of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
BOTH-CASE-P [Function]
Args: (char)
Returns T if CHAR is an alphabetic character and if CHAR exists in both upper
and lower case; NIL otherwise. Equivalent to ALPHA-CHAR-P.
------------------------------------------------------------------------------
BOUNDP [Function]
Args: (symbol)
Returns T if the dynamic (special) variable named by SYMBOL has a value; NIL
otherwise.
------------------------------------------------------------------------------
BREAK [Function]
Args: (&optional (format-string nil) &rest args)
Enters a break loop. If FORMAT-STRING is non-NIL, formats FORMAT-STRING
and ARGS to *ERROR-OUTPUT* before entering a break loop.
Typing :HELP at the break loop will list the break-loop commands.
------------------------------------------------------------------------------
*BREAK-ENABLE* [Variable]
KCL specific: Specifies whether (non-NIL) or not (NIL) the break loop is
entered when an error occurred.
------------------------------------------------------------------------------
*BREAK-ON-WARNINGS* [Variable]
If non-NIL, then WARN will enter a break loop before returning.
------------------------------------------------------------------------------
BUTLAST [Function]
Args: (list &optional (n 1))
Creates and returns a list with the same elements as LIST, excepting the
last N elements.
------------------------------------------------------------------------------
KCL Dictionary Page 11
------------------------------------------------------------------------------
BY [Function]
Args: ()
KCL specific: Exits from KCL.
------------------------------------------------------------------------------
BYE [Function]
Args: ()
KCL specific: Exits from KCL.
------------------------------------------------------------------------------
BYTE [Function]
Args: (size position)
Returns a byte specifier which may be used by other byte functions.
------------------------------------------------------------------------------
BYTE-POSITION [Function]
Args: (bytespec)
Returns the position part of the byte specifier.
------------------------------------------------------------------------------
BYTE-SIZE [Function]
Args: (bytespec)
Returns the size part of the byte specifier.
------------------------------------------------------------------------------
CAAAAR [Function]
Args: (x)
Equivalent to (CAR (CAR (CAR (CAR X)))).
------------------------------------------------------------------------------
CAAADR [Function]
Args: (x)
Equivalent to (CAR (CAR (CAR (CDR X)))).
------------------------------------------------------------------------------
CAAAR [Function]
Args: (x)
Equivalent to (CAR (CAR (CAR X))).
------------------------------------------------------------------------------
CAADAR [Function]
Args: (x)
Equivalent to (CAR (CAR (CDR (CAR X)))).
------------------------------------------------------------------------------
CAADDR [Function]
Args: (x)
Equivalent to (CAR (CAR (CDR (CDR X)))).
------------------------------------------------------------------------------
CAADR [Function]
Args: (x)
Equivalent to (CAR (CAR (CDR X))).
------------------------------------------------------------------------------
CAAR [Function]
Args: (x)
Equivalent to (CAR (CAR X)).
------------------------------------------------------------------------------
KCL Dictionary Page 12
------------------------------------------------------------------------------
CADAAR [Function]
Args: (x)
Equivalent to (CAR (CDR (CAR (CAR X)))).
------------------------------------------------------------------------------
CADADR [Function]
Args: (x)
Equivalent to (CAR (CDR (CAR (CDR X)))).
------------------------------------------------------------------------------
CADAR [Function]
Args: (x)
Equivalent to (CAR (CDR (CAR X))).
------------------------------------------------------------------------------
CADDAR [Function]
Args: (x)
Equivalent to (CAR (CDR (CDR (CAR X)))).
------------------------------------------------------------------------------
CADDDR [Function]
Args: (x)
Equivalent to (CAR (CDR (CDR (CDR X)))).
------------------------------------------------------------------------------
CADDR [Function]
Args: (x)
Equivalent to (CAR (CDR (CDR X))).
------------------------------------------------------------------------------
CADR [Function]
Args: (x)
Equivalent to (CAR (CDR X)).
------------------------------------------------------------------------------
CALL-ARGUMENTS-LIMIT [Constant]
The upper exclusive bound on the number of arguments that may be passed to
a function. Actually, however, there is no such upper bound in KCL.
------------------------------------------------------------------------------
CAR [Function]
Args: (list)
Returns the car of LIST. Returns NIL if LIST is NIL.
------------------------------------------------------------------------------
CASE [Macro]
Syntax: (case keyform {({key | ({key}*)} {form}*)}*)
Evaluates KEYFORM and tries to find the KEY that is EQL to the value of
KEYFORM. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, simply returns NIL.
------------------------------------------------------------------------------
CATCH [Special form]
Syntax: (catch tag {form}*)
Evaluates TAG and sets up a catcher with that value. Then evaluates FORMs
as a PROGN, but may possibly abort the evaluation by executing THROW with
the same tag value.
------------------------------------------------------------------------------
KCL Dictionary Page 13
------------------------------------------------------------------------------
CCASE [Macro]
Syntax: (ccase keyplace {({key | ({key}*)} {form}*)}*)
Evaluates KEYPLACE and tries to find the KEY that is EQL to the value of
KEYPLACE. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, signals an correctable error.
------------------------------------------------------------------------------
CDAAAR [Function]
Args: (x)
Equivalent to (CDR (CAR (CAR (CAR X)))).
------------------------------------------------------------------------------
CDAADR [Function]
Args: (x)
Equivalent to (CDR (CAR (CAR (CDR X)))).
------------------------------------------------------------------------------
CDAAR [Function]
Args: (x)
Equivalent to (CDR (CAR (CAR X))).
------------------------------------------------------------------------------
CDADAR [Function]
Args: (x)
Equivalent to (CDR (CAR (CDR (CAR X)))).
------------------------------------------------------------------------------
CDADDR [Function]
Args: (x)
Equivalent to (CDR (CAR (CDR (CDR X)))).
------------------------------------------------------------------------------
CDADR [Function]
Args: (x)
Equivalent to (CDR (CAR (CDR X))).
------------------------------------------------------------------------------
CDAR [Function]
Args: (x)
Equivalent to (CDR (CAR X)).
------------------------------------------------------------------------------
CDDAAR [Function]
Args: (x)
Equivalent to (CDR (CDR (CAR (CAR X)))).
------------------------------------------------------------------------------
CDDADR [Function]
Args: (x)
Equivalent to (CDR (CDR (CAR (CDR X)))).
------------------------------------------------------------------------------
CDDAR [Function]
Args: (x)
Equivalent to (CDR (CDR (CAR X))).
------------------------------------------------------------------------------
KCL Dictionary Page 14
------------------------------------------------------------------------------
CDDDAR [Function]
Args: (x)
Equivalent to (CDR (CDR (CDR (CAR X)))).
------------------------------------------------------------------------------
CDDDDR [Function]
Args: (x)
Equivalent to (CDR (CDR (CDR (CDR X)))).
------------------------------------------------------------------------------
CDDDR [Function]
Args: (x)
Equivalent to (CDR (CDR (CDR X))).
------------------------------------------------------------------------------
CDDR [Function]
Args: (x)
Equivalent to (CDR (CDR X)).
------------------------------------------------------------------------------
CDR [Function]
Args: (list)
Returns the cdr of LIST. Returns NIL if LIST is NIL.
------------------------------------------------------------------------------
CEILING [Function]
Args: (number &optional (divisor 1))
Returns the smallest integer not less than or NUMBER/DIVISOR. The second
returned value is the remainder.
------------------------------------------------------------------------------
CERROR [Function]
Args: (continue-format-string error-format-string &rest args)
Signals a correctable error.
------------------------------------------------------------------------------
CHAR [Function]
Args: (string index)
Returns the character object representing the INDEX-th character in STRING.
------------------------------------------------------------------------------
CHAR-BIT [Function]
Args: (char name)
Returns T if the named bit is set in the character CHAR; NIL otherwise.
This function is useless in KCL.
------------------------------------------------------------------------------
CHAR-BITS [Function]
Args: (char)
Returns the bits attribute (which is always 0) of CHAR.
------------------------------------------------------------------------------
CHAR-BITS-LIMIT [Constant]
The upper exclusive bound on values produced by CHAR-BITS.
------------------------------------------------------------------------------
KCL Dictionary Page 15
------------------------------------------------------------------------------
CHAR-CODE [Function]
Args: (char)
Returns the code attribute of CHAR.
------------------------------------------------------------------------------
CHAR-CODE-LIMIT [Constant]
The upper exclusive bound on values produced by CHAR-CODE.
------------------------------------------------------------------------------
CHAR-CONTROL-BIT [Constant]
The bit that indicates a control character.
------------------------------------------------------------------------------
CHAR-DOWNCASE [Function]
Args: (char)
Returns a character with the same bits and font as CHAR, converted to
lower-case if possible.
------------------------------------------------------------------------------
CHAR-EQUAL [Function]
Args: (char &rest more-chars)
Returns T if all of its arguments are the same character; NIL otherwise.
Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-FONT [Function]
Args: (char)
Returns the font attribute of CHAR.
------------------------------------------------------------------------------
CHAR-FONT-LIMIT [Constant]
The upper exclusive bound on values produced by CHAR-FONT.
------------------------------------------------------------------------------
CHAR-GREATERP [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly decreasing alphabetic order; NIL
otherwise. Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-HYPER-BIT [Constant]
The bit that indicates a hyper character.
------------------------------------------------------------------------------
CHAR-INT [Function]
Args: (char)
Returns the font, bits, and code attributes as a single non-negative integer.
Equivalent to CHAR-CODE in KCL.
------------------------------------------------------------------------------
CHAR-LESSP [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly increasing alphabetic order; NIL
otherwise. Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-META-BIT [Constant]
The bit that indicates a meta character.
------------------------------------------------------------------------------
KCL Dictionary Page 16
------------------------------------------------------------------------------
CHAR-NAME [Function]
Args: (char)
Returns the name for CHAR as a string; NIL if CHAR has no name.
Only #\Backspace, #\Tab, #\Newline (or #\Linefeed), #\Page, #\Return,
and #\Rubout have names.
------------------------------------------------------------------------------
CHAR-NOT-EQUAL [Function]
Args: (char &rest more-chars)
Returns T if no two of CHARs are the same character; NIL otherwise.
Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-NOT-GREATERP [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly non-decreasing alphabetic order; NIL
otherwise. Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-NOT-LESSP [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly non-increasing alphabetic order; NIL
otherwise. Font, bits, and case are ignored.
------------------------------------------------------------------------------
CHAR-SUPER-BIT [Constant]
The bit that indicates a super character.
------------------------------------------------------------------------------
CHAR-UPCASE [Function]
Args: (char)
Returns a character with the same bits and font as CHAR, converted to
upper-case if possible.
------------------------------------------------------------------------------
CHAR/= [Function]
Args: (char &rest more-chars)
Returns T if no two of CHARs are the same character; NIL otherwise.
------------------------------------------------------------------------------
CHAR< [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly increasing alphabetic order; NIL
otherwise.
------------------------------------------------------------------------------
CHAR<= [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly non-decreasing alphabetic order; NIL
otherwise.
------------------------------------------------------------------------------
CHAR= [Function]
Args: (char &rest more-chars)
Returns T if all CHARs are the same character; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 17
------------------------------------------------------------------------------
CHAR> [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly decreasing alphabetic order; NIL
otherwise.
------------------------------------------------------------------------------
CHAR>= [Function]
Args: (char &rest more-chars)
Returns T if CHARs are in strictly non-increasing alphabetic order; NIL
otherwise.
------------------------------------------------------------------------------
CHARACTER [Type]
A character object represents a character. Characters have font, bits, and
code attributes. Font and bits attributes are always 0 in KCL. Most versions
of KCL uses ASCII code:
000 - 037 #\^@ #\^A #^B ... #\Z #\^[ #\^\ #\^] #\^^ #\^_
except #\Tab(011) #\Newline(012) #\Page(014)
#\Return(015) #\Backspace(031)
040 - 057 #\Space #\! #\" #\# #\$ #\% #\& #\' #\( #\) #\*
#\+ #\, #\- #\. #\/
060 - 071 #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9
072 - 100 #\: #\; #\< #\= #\> #\? #\@
101 - 132 #\A ... #\Z
133 - 140 #\[ #\\ #\] #\^ #\_ #\`
141 - 172 #\a ... #\z
173 - 177 #\{ #\| #\} #\~ #\Rubout
Some versions of KCL support additional characters to represent Japanese
KANJI characters with.
------------------------------------------------------------------------------
CHARACTER [Function]
Args: (x)
Coerces X into a character object if possible.
------------------------------------------------------------------------------
CHARACTERP [Function]
Args: (x)
Returns T if X is a character; NIL otherwise.
------------------------------------------------------------------------------
CHECK-TYPE [Macro]
Syntax: (check-type place typespec [string])
Signals an error, if the contents of PLACE are not of the specified type.
------------------------------------------------------------------------------
CIS [Function]
Args: (radians)
Returns e raised to i*RADIANS.
------------------------------------------------------------------------------
CLEAR-INPUT [Function]
Args: (&optional (stream *standard-input*))
Clears any buffered input associated with STREAM.
------------------------------------------------------------------------------
KCL Dictionary Page 18
------------------------------------------------------------------------------
CLEAR-OUTPUT [Function]
Args: (&optional (stream *standard-output*))
Clears the output stream STREAM.
------------------------------------------------------------------------------
CLINES [Macro]
Syntax: (clines {string}*)
KCL specific: The KCL compiler embeds STRINGs into the intermediate C
language code. The interpreter ignores this form.
------------------------------------------------------------------------------
CLOSE [Function]
Args: (stream &key (abort nil))
Closes STREAM. A non-NIL value of :ABORT indicates an abnormal termination
of the use of the stream.
------------------------------------------------------------------------------
CLRHASH [Function]
Args: (hash-table)
Removes all entries of HASH-TABLE and returns the hash table itself.
------------------------------------------------------------------------------
CODE-CHAR [Function]
Args: (code &optional (bits 0) (font 0))
Returns a character object with the specified code, bits, and font,
or returns NIL if this is not possible.
------------------------------------------------------------------------------
COERCE [Function]
Args: (x type)
Coerces X to an object of the type TYPE.
------------------------------------------------------------------------------
COMMON [Type]
COMMON is the type of all legal Common Lisp data types.
------------------------------------------------------------------------------
COMMONP [Function]
Args: (x)
Returns T if X is a legal Common Lisp object; NIL otherwise.
------------------------------------------------------------------------------
COMPILE [Function]
Args: (name &optional (definition nil) &key (leave-gazonk nil))
If DEFINITION is NIL, NAME must be the name of a not-yet-compiled
function. In this case, COMPILE compiles the function, installs the compiled
function as the global function definition of NAME, and returns NAME.
If DEFINITION is non-NIL, it must be a lambda expression and NAME must be
a symbol. COMPILE compiles the lambda expression, installs the compiled
function as the function definition of NAME, and returns NAME.
There is only one exception for this: If NAME is NIL, then the compiled
function is not installed but is simply returned as the value of COMPILE.
In any case, COMPILE creates temporary files whose filenames are
"gazonk***". By default, i.e. if :LEAVE-GAZONK is not supplied or is
NIL, these files are automatically deleted after compilation.
------------------------------------------------------------------------------
KCL Dictionary Page 19
------------------------------------------------------------------------------
COMPILE-FILE [Function]
Args: (input-pathname
&key output-file (load nil) (message-file nil) (verbose nil))
Compiles the file specified by INPUT-PATHNAME and generates a fasl file
specified by OUTPUT-FILE. If the filetype is not specified in
INPUT-PATHNAME, then ".lsp" is used as the default file type for the
source file. :LOAD specifies whether to load the generated fasl file
after compilation. :MESSAGE-FILE specifies the log file for the compiler
messages. It defaults to the value of the variable COMPILER:*DEFAULT-
MESSAGE-FILE*. A non-NIL value of :VERBOSE forces the compiler to indicate
the form currently being compiled. More keyword parameters are accepted,
depending on the version. Most versions of KCL can receive :O-FILE, :C-FILE,
:H-FILE, and :DATA-FILE keyword parameters, with which you can control the
intermediate files generated by the KCL compiler. See the KCL Report
at your hand for the details.
------------------------------------------------------------------------------
COMPILED-FUNCTION [Type]
A compiled function is a compiled code object. A compiled function is
denoted in either of the form:
#<compiled-function ?>
#<compiled-closure nil>
where '?' is actually the name of the compiled-function.
------------------------------------------------------------------------------
COMPILED-FUNCTION-P [Function]
Args: (x)
Returns T if X is a compiled function object; NIL otherwise.
------------------------------------------------------------------------------
COMPILER-LET [Special form]
Syntax: (compiler-let ({var | (var [value])}*) {form}*)
In the interpreter, works just like LET with all VARs declared special.
On the other hand, the compiler processes FORMs with the VARs bound in the
compiler's environment, and the compiled code causes no bindings.
------------------------------------------------------------------------------
COMPLEX [Type]
A complex number consists of a real part and an imaginary part. A complex
number is denoted as
#c( realpart imagpart ) or #C( realpart imagpart )
where realpart and imagpart are non-complex numbers.
------------------------------------------------------------------------------
COMPLEX [Function]
Args: (realpart &optional (imagpart 0))
Returns a complex number with the given real part and imaginary part.
------------------------------------------------------------------------------
COMPLEXP [Function]
Args: (x)
Returns T if X is a complex number; NIL otherwise.
------------------------------------------------------------------------------
CONCATENATE [Function]
Args: (result-type &rest sequences)
Returns a new sequence of all SEQUENCEs concatenated together of the specified
RESULT-TYPE.
------------------------------------------------------------------------------
KCL Dictionary Page 20
------------------------------------------------------------------------------
COND [Macro]
Syntax: (cond {(test {form}*)}*)
Evaluates each TEST in order until one evaluates to non-NIL. Then evaluates
the associated FORMs in order and returns whatever the last FORM returns.
If all TESTs evaluate to NIL, simply returns NIL.
------------------------------------------------------------------------------
CONJUGATE [Function]
Args: (number)
Returns the complex conjugate of NUMBER. For non-complex numbers, this is
an identity.
------------------------------------------------------------------------------
CONS [Type]
A cons is a record structure containing two components called the car and the
cdr.
------------------------------------------------------------------------------
CONS [Function]
Args: (x y)
Returns a new cons whose car and cdr are X and Y, respectively.
------------------------------------------------------------------------------
CONSP [Function]
Args: (x)
Returns T if X is a cons; NIL otherwise.
------------------------------------------------------------------------------
CONSTANTP [Function]
Args: (symbol)
Returns T if the variable named by SYMBOL is a constant; NIL otherwise.
------------------------------------------------------------------------------
COPY-ALIST [Function]
Args: (alist)
Returns a new association list EQUAL but not EQ to ALIST.
------------------------------------------------------------------------------
COPY-LIST [Function]
Args: (list)
Returns a new list EQUAL but not EQ to LIST.
------------------------------------------------------------------------------
COPY-READTABLE [Function]
Args: (&optional (from-readtable *readtable*) (to-readtable nil))
Returns a copy of the readtable FROM-READTABLE. If TO-READTABLE is non-NIL,
then copies into TO-READTABLE. Otherwise, creates a fresh readtable.
------------------------------------------------------------------------------
COPY-SEQ [Function]
Args: (sequence)
Returns a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
------------------------------------------------------------------------------
KCL Dictionary Page 21
------------------------------------------------------------------------------
COPY-SYMBOL [Function]
Args: (symbol &optional (copy-props nil))
Creates and returns a new uninterned symbol with the same print name as
SYMBOL. If COPY-PROPS is NIL, the new symbol has no properties. Else, it
is given a copy of SYMBOL's property list.
------------------------------------------------------------------------------
COPY-TREE [Function]
Args: (object)
Recursively copies trees of conses in OBJECT and returns the result.
------------------------------------------------------------------------------
COS [Function]
Args: (radians)
Returns the cosine of RADIANS.
------------------------------------------------------------------------------
COSH [Function]
Args: (number)
Returns the hyperbolic cosine of NUMBER.
------------------------------------------------------------------------------
COUNT [Function]
Args: (item sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
Returns the number of elements in SEQUENCE satisfying TEST with ITEM.
------------------------------------------------------------------------------
COUNT-IF [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the number of elements in SEQUENCE satisfying TEST.
------------------------------------------------------------------------------
COUNT-IF-NOT [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the number of elements in SEQUENCE not satisfying TEST.
------------------------------------------------------------------------------
CTYPECASE [Macro]
Syntax: (ctypecase keyplace {(type {form}*)}*)
Evaluates KEYPLACE and tries to find the TYPE in which the value of KEYPLACE
belongs. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, signals a correctable error.
------------------------------------------------------------------------------
*DEBUG-IO* [Variable]
The interactive debugging stream.
------------------------------------------------------------------------------
DECF [Macro]
Syntax: (decf place [delta])
Subtracts the number produced by DELTA (which defaults to 1) from the number
in PLACE.
------------------------------------------------------------------------------
KCL Dictionary Page 22
------------------------------------------------------------------------------
DECLARE [Special form]
Syntax: (declare {decl-spec}*)
Gives a declaration. Possible DECL-SPECs are:
(SPECIAL {var}*)
(TYPE type {var}*)
(type {var}*) : where 'type' is one of the following symbols
array fixnum package simple-bit-vector
atom float pathname simple-string
bignum function random-state simple-vector
bit hash-table ratio single-float
bit-vector integer rational standard-char
character keyword readtable stream
common list sequence string
compiled-function long-float short-float string-char
complex nil signed-byte symbol
cons null unsigned-byte t
double-float number simple-array vector
(OBJECT {var}*)
(FTYPE type {function-name}*)
(FUNCTION ({arg-type}*) {return-type}*)
(INLINE {function-name}*)
(NOTINLINE {function-name}*)
(IGNORE {var}*)
(OPTIMIZE {({SPEED | SPACE | SAFETY | COMPILATION-SPEED} {0 | 1 | 2 | 3})}*)
(DECLARATION {non-standard-decl-name}*).
------------------------------------------------------------------------------
DECODE-FLOAT [Function]
Args: (float)
Returns three values. The first value is a floating-point number that
represents the significand of FLOAT. The second value is an integer that
represents the exponent of FLOAT. The third value is a floating-point number
that indicates the sign of FLOAT.
------------------------------------------------------------------------------
DECODE-UNIVERSAL-TIME [Function]
Args: (universal-time &optional (timezone -9))
Converts UNIVERSAL-TIME into the decoded time format at the TIMEZONE.
Returns nine values: second, minute, hour, date, month, year, day-of-week,
daylight-saving-time-p, and time-zone. TIMEZONE in KCL defaults to -9, which
is the time zone in Japan.
------------------------------------------------------------------------------
*DEFAULT-PATHNAME-DEFAULTS* [Variable]
The default pathname-defaults pathname.
------------------------------------------------------------------------------
KCL Dictionary Page 23
------------------------------------------------------------------------------
DEFCFUN [Macro]
Syntax: (defcfun header n {element}*)
KCL specific: Defines a C-language function which calls Lisp functions and/or
handles Lisp objects. HEADER gives the header of the C function as a string.
N is the number of the main stack entries used by the C function, primarily
for protecting Lisp objects from being garbage-collected. Each ELEMENT may
give a C code fragment as a string, or it may be a list
((symbol {arg}*) {place}*)
which, when executed, calls the Lisp function named by SYMBOL with the
specified arguments and saves the value(s) to the specified places.
The DEFCFUN form has the above meanings only after compiled; The KCL
interpreter simply ignores this form.
------------------------------------------------------------------------------
DEFCONSTANT [Macro]
Syntax: (defconstant name initial-value [doc])
Declares that the variable NAME is constant. If the variable already has
a value, and this is not equal to the value of INITIAL-VALUE, an error is
signalled. The doc-string DOC, if supplied, is saved as a VARIABLE doc and
can be retrieved by (documentation 'NAME 'variable).
------------------------------------------------------------------------------
DEFENTRY [Macro]
Syntax: (defentry name lambda-list C-function)
KCL specific: The compiler defines a Lisp function whose body consists of
a calling sequence to the C language function specified by C-FUNCTION. The
interpreter ignores this form. See the doc of DEFUN for the complete syntax
of a lambda-list.
------------------------------------------------------------------------------
DEFINE-MODIFY-MACRO [Macro]
Syntax: (define-modify-macro name lambda-list fun [doc])
Defines a read-modify-write macro, like PUSH or INCF. The defined macro will
expand a form (NAME place val1 ... valn) into a form that in effect SETFs the
value of the call (FUN PLACE arg1 ... argm) into PLACE, where arg1 ... argm
are parameters in LAMBDA-LIST which are bound to the forms VAL1 ... VALn.
The doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved
by (documentation 'NAME 'setf).
------------------------------------------------------------------------------
KCL Dictionary Page 24
------------------------------------------------------------------------------
DEFINE-SETF-METHOD [Macro]
Syntax: (define-setf-method access-fun defmacro-lambda-list {decl | doc}*
{form}*)
Defines how to SETF a generalized-variable reference of the form
(ACCESS-FUN ...). When a form (setf (ACCESS-FUN arg1 ... argn) value) is
being evaluated, the FORMs are first evaluated as a PROGN with the parameters
in DEFMACRO-LAMBDA-LIST bound to ARG1 ... ARGn. Assuming that the last FORM
returns five values
(temp-var-1 ... temp-var-k)
(value-from-1 ... value-form-k)
(store-var)
storing-form
access-form
in order, the whole SETF is then expanded into
(let* ((temp-var-1 value-from-1) ... (temp-k value-form-k)
(store-var VALUE))
storing-from)
Incidentally, the five values are called the five gangs of a SETF method.
The doc-string DOC, if supplied, is saved as a SETF doc and can be retrieved
by (documentation 'NAME 'setf).
------------------------------------------------------------------------------
DEFLA [Macro]
Syntax: (defla name lambda-list {decl | doc}* {form}*)
KCL specific: Used to DEFine Lisp Alternative. For the interpreter, DEFLA is
equivalent to DEFUN, but the compiler ignores this form.
------------------------------------------------------------------------------
KCL Dictionary Page 25
------------------------------------------------------------------------------
DEFMACRO [Macro]
Syntax: (defmacro name defmacro-lambda-list {decl | doc}* {form}*)
Defines a macro as the global macro definition of the symbol NAME.
The complete syntax of a defmacro-lambda-list is:
( [&whole var]
[&environment var]
{pseudo-var}*
[&optional {var | (pseudo-var [initform [pseudo-var]])}*]
{[{&rest | &body} pseudo-var]
[&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}*
[&allow-other-keys]]
[&aux {var | (pseudo-var [initform])}*]
| . var})
where pseudo-var is either a symbol or a list of the following form:
( {pseudo-var}*
[&optional {var | (pseudo-var [initform [pseudo-var]])}*]
{[{&rest | &body} pseudo-var]
[&key {var | ({var | (keyword pseudo-var)} [initform [pseudo-var]])}*
[ &allow-other-keys ] ]
[&aux {var | (pseudo-var [initform])}*]
| . var})
As a special case, a non-NIL symbol is accepcted as a defmacro-lambda-list:
(DEFMACRO <name> <symbol> ...) is equivalent to
(DEFMACRO <name> (&REST <symbol>) ...).
The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be
retrieved by (documentation 'NAME 'function).
See the type doc of LIST for the backquote macro useful for defining macros.
Also, see the function doc of PPRINT for the output-formatting.
------------------------------------------------------------------------------
DEFPARAMETER [Macro]
Syntax: (defparameter name initial-value [doc])
Defines a parameter which is not normally changed by the program, but which
may be changed without causing an error. Declares the variable as special and
initializes the value. The doc-string DOC, if supplied, is saved as a
VARIABLE doc and can be retrieved by (documentation 'NAME 'variable).
------------------------------------------------------------------------------
DEFSETF [Macro]
Syntax: (defsetf access-fun {update-fun [doc] |
lambda-list (store-var) {decl | doc}* {form}*)
Defines how to SETF a generalized-variable reference of the form
(ACCESS-FUN ...). The doc-string DOC, if supplied, is saved as a SETF doc and
can be retrieved by (documentation 'NAME 'setf).
(defsetf access-fun update-fun) defines an expansion from
(setf (ACCESS-FUN arg1 ... argn) value) to (UPDATE-FUN arg1 ... argn value).
(defsetf access-fun lambda-list (store-var) . body) defines a macro which
expands (setf (ACCESS-FUN arg1 ... argn) value) into the form
(let* ((temp1 ARG1) ... (tempn ARGn) (temp0 value)) rest)
where REST is the value of BODY with parameters in LAMBDA-LIST bound to the
symbols TEMP1 ... TEMPn and with STORE-VAR bound to the symbol TEMP0.
------------------------------------------------------------------------------
KCL Dictionary Page 26
------------------------------------------------------------------------------
DEFSTRUCT [Macro]
Syntax: (defstruct
{name | (name {:conc-name | (:conc-name prefix-string) |
:constructor | (:constructor symbol [lambda-list]) |
:copier | (:copier symbol) |
:predicate | (:predicate symbol) |
(:include symbol) |
(:print-function function) |
(:type {vector | (vector type) | list}) |
:named |
(:initial-offset number)}*)}
[doc]
{slot-name |
(slot-name [default-value-form] {:type type | :read-only flag}*) }*
)
Defines a structure. The doc-string DOC, if supplied, is saved as a STRUCTURE
doc and can be retrieved by (documentation 'NAME 'structure).
------------------------------------------------------------------------------
DEFTYPE [Macro]
Syntax: (deftype name lambda-list {decl | doc}* {form}*)
Defines a new type-specifier abbreviation in terms of an 'expansion' function
(lambda lambda-list1 {decl}* {form}*)
where lambda-list1 is identical to LAMBDA-LIST except that all optional
parameters with no default value specified in LAMBDA-LIST defaults to the
symbol '*', but not to NIL. When the type system of KCL encounters a
type specifier (NAME arg1 ... argn), it calls the expansion function with
the arguments arg1 ... argn, and uses the returned value instead of the
original type specifier. When the symbol NAME is used as a type specifier,
the expansion function is called with no argument. The doc-string DOC, if
supplied, is saved as the TYPE doc of NAME, and is retrieved by
(documentation 'NAME 'type).
------------------------------------------------------------------------------
DEFUN [Macro]
Syntax: (defun name lambda-list {decl | doc}* {form}*)
Defines a function as the global function definition of the symbol NAME.
The complete syntax of a lambda-list is:
({var}*
[&optional {var | (var [initform [svar]])}*]
[&rest var]
[&key {var | ({var | (keyword var)} [initform [svar]])}*
[&allow-other-keys]]
[&aux {var | (var [initform])}*])
The doc-string DOC, if supplied, is saved as a FUNCTION doc and can be
retrieved by (documentation 'NAME 'function).
------------------------------------------------------------------------------
DEFVAR [Macro]
Syntax: (defvar name [initial-value [doc]])
Declares the variable NAME as special and, optionally, initializes it.
The doc-string DOC, if supplied, is saved as a VARIABLE doc and can be
retrieved by (documentation 'NAME 'variable).
------------------------------------------------------------------------------
KCL Dictionary Page 27
------------------------------------------------------------------------------
DELETE [Function]
Args: (item sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (count most-positive-fixnum)
(key #'identity))
Returns a sequence formed by destructively removing the specified ITEM from
the SEQUENCE.
------------------------------------------------------------------------------
DELETE-DUPLICATES [Function]
Args: (sequence &key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
The elements of SEQUENCE are examined, and if any two match, one is discarded.
Returns the resulting sequence, which may be formed by destroying SEQUENCE.
------------------------------------------------------------------------------
DELETE-FILE [Function]
Args: (file)
Deletes the file specified by FILE.
------------------------------------------------------------------------------
DELETE-IF [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence formed by destructively removing the elements satisfying
TEST from SEQUENCE.
------------------------------------------------------------------------------
DELETE-IF-NOT [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence formed by destructively removing the elements not
satisfying TEST from SEQUENCE.
------------------------------------------------------------------------------
DENOMINATOR [Function]
Args: (rational)
Returns as an integer the denominator of the given rational number.
------------------------------------------------------------------------------
DEPOSIT-FIELD [Function]
Args: (newbyte bytespec integer)
Returns an integer that contains the bits of NEWBYTE within the byte specified
by BYTESPEC, and elsewhere contains the bits of INTEGER.
------------------------------------------------------------------------------
DESCRIBE [Function]
Args: (x)
Prints a description of the object X on the standard output.
------------------------------------------------------------------------------
DIGIT-CHAR [Function]
Args: (weight &optional (radix 10) (font 0))
Returns a character object that represents a digit of the given WEIGHT in
the specified RADIX. Returns NIL if no such character exists. The character
will have the specified FONT attribute.
------------------------------------------------------------------------------
KCL Dictionary Page 28
------------------------------------------------------------------------------
DIGIT-CHAR-P [Function]
Args: (char &optional (radix 10))
Returns T if CHAR represents a digit in RADIX; NIL otherwise.
------------------------------------------------------------------------------
DIRECTORY [Function]
Args: (name)
Returns a list of files that match NAME. NAME may be a string, a pathname,
or a file stream.
------------------------------------------------------------------------------
DIRECTORY-NAMESTRING [Function]
Args: (pathname)
Returns the device and directory parts of PATHNAME as a string.
------------------------------------------------------------------------------
DISASSEMBLE [Function]
Args: (&optional (thing nil) &key (h-file nil) (data-file nil))
Compiles the form specified by THING and prints the intermediate C language
code for that form. But does NOT install the result of compilation.
If THING is NIL, then the previously disassembled form is re-disassembled.
If THING is a symbol that names a not-yet-compiled function, the function
definition is disassembled.
If THING is a lambda expression, it is disassembled as a function definition.
Otherwise, THING itself is disassembled as a top-level form.
------------------------------------------------------------------------------
DO [Macro]
Syntax: (do ({(var [init [step]])}*) (endtest {result}*)
{decl}* {tag | statement}*)
Creates a NIL block, binds each VAR to the value of the corresponding
INIT, then executes STATEMENTs repeatedly until ENDTEST is satisfied. After
each iteration, assigns to each VAR the value of the corresponding STEP. When
ENDTEST is satisfied, evaluates RESULTs as a PROGN and returns. Performs
variable bindings and assignments all at once, just like LET and PSETQ do.
------------------------------------------------------------------------------
DO* [Macro]
Syntax: (do* ({(var [init [step]])}*) (endtest {result}*)
{decl}* {tag | statement}*)
Just like DO, but performs variable bindings and assignments in serial, just
like LET* and SETQ do.
------------------------------------------------------------------------------
DO-ALL-SYMBOLS [Macro]
Syntax: (do-all-symbols (var [result-form]) {decl}* {tag | statement}*)
Executes STATEMENTs once for each symbol in each package with VAR bound to
the current symbol. Then evaluates RESULT-FORM (which defaults to NIL) and
returns the value.
------------------------------------------------------------------------------
DO-EXTERNAL-SYMBOLS [Macro]
Syntax: (do-external-symbols (var [package [result-form]])
{decl}* {tag | statement}*)
Executes STATEMENTs once for each external symbol in the PACKAGE (which
defaults to the current package) with VAR bound to the current symbol. Then
evaluates RESULT-FORM (which defaults to NIL) and returns the value.
------------------------------------------------------------------------------
KCL Dictionary Page 29
------------------------------------------------------------------------------
DO-SYMBOLS [Macro]
Syntax: (do-symbols (var [package [result-form]]) {decl}* {tag | statement}*)
Executes STATEMENTs once for each symbol in the PACKAGE (which defaults to
the current package) with VAR bound to the current symbol. Then evaluates
RESULT-FORM (which defaults to NIL) and returns the value.
------------------------------------------------------------------------------
DOCUMENTATION [Function]
Args: (symbol doc-type)
Returns the doc-string of DOC-TYPE for SYMBOL; NIL if none exists.
Possible doc-types are:
FUNCTION (special forms, macros, and functions)
VARIABLE (dynamic variables, including constants)
TYPE (types defined by DEFTYPE)
STRUCTURE (structures defined by DEFSTRUCT)
SETF (SETF methods defined by DEFSETF, DEFINE-SETF-METHOD, and
DEFINE-MODIFY-MACRO)
All built-in special forms, macros, functions, and variables have their
doc-strings.
------------------------------------------------------------------------------
DOLIST [Macro]
Syntax: (dolist (var listform [result]) {decl}* {tag | statement}*)
Executes STATEMENTs with VAR bound to each member of the list value of
LISTFORM, then returns the value of RESULT which defaults to NIL.
------------------------------------------------------------------------------
DOTIMES [Macro]
Syntax: (dotimes (var countform [result]) {decl}* {tag | statement}*)
Executes STATEMENTs with VAR increasing from 0 (inclusive) to the value of
COUNTFORM (exclusive). Returns the value of RESULT which defaults to NIL.
------------------------------------------------------------------------------
DOUBLE-FLOAT-EPSILON [Constant]
Same as LONG-FLOAT-EPSILON.
------------------------------------------------------------------------------
DOUBLE-FLOAT-NEGATIVE-EPSILON [Constant]
Same as LONG-FLOAT-NEGATIVE-EPSILON.
------------------------------------------------------------------------------
DPB [Function]
Args: (newbyte bytespec integer)
Returns the same number as INTEGER except in the specified bits which are
occupied by the bits from NEWBYTE.
------------------------------------------------------------------------------
DRIBBLE [Function]
Args: (&optional pathname)
If PATHNAME is given, begins to send a record of the interaction to the
specified file. If not, terminates the recording.
------------------------------------------------------------------------------
ECASE [Macro]
Syntax: (ecase keyform {({key | ({key}*)} {form}*)}*)
Evaluates KEYFORM and tries to find the KEY that is EQL to the value of
KEYFORM. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, signals an error.
------------------------------------------------------------------------------
KCL Dictionary Page 30
------------------------------------------------------------------------------
ED [Function]
Args: (&optional x)
Invokes the editor. The action depends on the version of KCL. See the
KCL Report for details.
------------------------------------------------------------------------------
EIGHTH [Function]
Args: (x)
Equivalent to (CADDDR (CDDDDR X)).
------------------------------------------------------------------------------
ELT [Function]
Args: (sequence index)
Returns the element of SEQUENCE specified by INDEX. The first element of
a sequence has index 0.
------------------------------------------------------------------------------
ENCODE-UNIVERSAL-TIME [Function]
Args: (second minute hour date month year &optional (timezone -9))
Encodes the time specified by the arguments into universal time format, and
returns it. TIMEZONE in KCL defaults to -9, the time zone in Japan.
------------------------------------------------------------------------------
ENDP [Function]
Args: (x)
Returns T if X is NIL. Returns NIL if X is a cons. Otherwise, signals an
error.
------------------------------------------------------------------------------
ENOUGH-NAMESTRING [Function]
Args: (pathname &optional (defaults *default-pathname-defaults*))
Returns a string which uniquely identifies PATHNAME with respect to
DEFAULTS.
------------------------------------------------------------------------------
EQ [Function]
Args: (x y)
Returns T if X and Y are the same identical object; NIL otherwise.
------------------------------------------------------------------------------
EQL [Function]
Args: (x y)
Returns T if X and Y are EQ, or if they are numbers of the same type with
the same value, or if they are character objects that represent the same
character. Returns NIL otherwise.
------------------------------------------------------------------------------
EQUAL [Function]
Args: (x y)
Returns T if X and Y are EQL or if they are of the same type and corresponding
components are EQUAL. Returns NIL otherwise. Strings and bit-vectors are
EQUAL if they are the same length and have identical components. Other
arrays must be EQ to be EQUAL.
------------------------------------------------------------------------------
KCL Dictionary Page 31
------------------------------------------------------------------------------
EQUALP [Function]
Args: (x y)
Returns T if X and Y are EQUAL; if they are characters and satisfy CHAR-EQUAL;
if they are numbers and have the same numerical value; or if they have
components that are all EQUALP. Returns NIL otherwise.
------------------------------------------------------------------------------
ERROR [Function]
Args: (control-string &rest args)
Signals a fatal error. CONTROL-STRING and ARGS are formatted to
*ERROR-OUTPUT*.
------------------------------------------------------------------------------
*ERROR-OUTPUT* [Variable]
The error output stream.
------------------------------------------------------------------------------
ETYPECASE [Macro]
Syntax: (etypecase keyform {(type {form}*)}*)
Evaluates KEYFORM and tries to find the TYPE in which the value of KEYFORM
belongs. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, signals an error.
------------------------------------------------------------------------------
EVAL [Function]
Args: (exp)
Evaluates its single arg in a null lexical environment, returns the
result or results.
------------------------------------------------------------------------------
EVAL-WHEN [Special form]
Syntax: (eval-when ({situation}*) {form}*)
Each situation must be a symbol, either COMPILE, LOAD, or EVAL. If the symbol
EVAL is specified as a SITUATION, FORMs are evaluated by the interpreter.
If COMPILE is specified, FORMs are evaluated within the compiler environment.
If LOAD is specified, the compiler arranges for FORMs to be evaluated when
the compiled file is loaded.
------------------------------------------------------------------------------
*EVAL-WHEN-COMPILE* [Variable]
KCL specific: Tells the KCL compiler whether (non-NIL) or not (NIL) the
compiler should process top-level forms in compile-time-too mode.
------------------------------------------------------------------------------
EVALHOOK [Function]
Args: (form evalhookfn applyhookfn &optional (env nil))
Evaluates FORM with *EVALHOOK* bound to EVALHOOKFN and *APPLYHOOK* bound
to APPLYHOOKFN. Ignores these hooks once, for the top-level evaluation
of FORM.
------------------------------------------------------------------------------
*EVALHOOK* [Variable]
Used to substitute another function for EVAL, for use by STEP, etc.
If *EVALHOOK* is not NIL, its value must be a function that can receive
two arguments: a form to evaluate and an environment. This function does
the evaluation instead of EVAL.
------------------------------------------------------------------------------
KCL Dictionary Page 32
------------------------------------------------------------------------------
EVENP [Function]
Args: (integer)
Returns T if INTEGER is even; NIL otherwise.
------------------------------------------------------------------------------
EVERY [Function]
Args: (predicate sequence &rest more-sequences)
PREDICATE is applied to the 0-th elements of SEQUENCEs, then possibly 1-st
elments, and so on. Returns NIL as soon as any invocation of PREDICATE
returns NIL, or T if every invocation is non-NIL.
------------------------------------------------------------------------------
EXP [Function]
Args: (number)
Calculates e raised to the power NUMBER, where e is the base of natural
logarithms.
------------------------------------------------------------------------------
EXPORT [Function]
Args: (symbols &optional (package *package*))
Makes SYMBOLS accessible as external symbols in PACKAGE. SYMBOLS must be a
list of symbols or a symbol.
------------------------------------------------------------------------------
EXPT [Function]
Args: (base-number power-number)
Returns BASE-NUMBER raised to the power POWER-NUMBER.
------------------------------------------------------------------------------
FBOUNDP [Function]
Args: (symbol)
Returns T if SYMBOL has a global function definition or if SYMBOL names a
special form or a macro; NIL otherwise.
------------------------------------------------------------------------------
FCEILING [Function]
Args: (number &optional (divisor 1))
Same as CEILING, but returns first value as a float.
------------------------------------------------------------------------------
*FEATURES* [Variable]
List of symbols that name features of the current version of KCL.
These features are used to decide the read-time conditionalization facility
provided by '#+' and '#-' read macros. When the KCL reader encounters
#+ feature-description form
it reads FORM in the usual manner if FEATURE-DESCRIPTION is true. Otherwise,
the reader just skips FORM.
#- feature-description form
is equivalent to
#- (not feature-description) form
A feature-description may be a symbol, which is true only when it is an
element of *FEATURES*. Or else, it must be one of the following:
(and feature-desciption-1 ... feature-desciption-n)
(or feature-desciption-1 ... feature-desciption-n)
(not feature-desciption)
The AND description is true only when all of its sub-descriptions are true.
The OR description is true only when at least one of its sub-descriptions is
true. The NOT description is true only when its sub-description is false.
------------------------------------------------------------------------------
KCL Dictionary Page 33
------------------------------------------------------------------------------
FFLOOR [Function]
Args: (number &optional (divisor 1))
Same as FLOOR, but returns first value as a float.
------------------------------------------------------------------------------
FIFTH [Function]
Args: (x)
Equivalent to (CAR (CDDDDR X)).
------------------------------------------------------------------------------
FILE-AUTHOR [Function]
Args: (file)
Returns the name of the author of the specified file, as a string.
FILE may be a string or a stream
------------------------------------------------------------------------------
FILE-LENGTH [Function]
Args: (file-stream)
Returns the length of the specified stream.
------------------------------------------------------------------------------
FILE-NAMESTRING [Function]
Args: (pathname)
Returns the name, type, and version of PATHNAME as a string.
------------------------------------------------------------------------------
FILE-POSITION [Function]
Args: (file-stream &optional position)
With one argument, this function returns the current file position of
the specified file, as an integer. If POSITION is given, this function
sets the file position of the specified file to POSITION.
------------------------------------------------------------------------------
FILE-WRITE-DATE [Function]
Args: (file)
Returns the time at which the specified file is written, as an integer in
universal time format. FILE may be a string or a stream
------------------------------------------------------------------------------
FILL [Function]
Args: (sequence item &key (start 0) (end (length sequence)))
Replaces the specified elements of SEQUENCE with ITEM.
------------------------------------------------------------------------------
FILL-POINTER [Function]
Args: (vector)
Returns the fill pointer of VECTOR. Signals an error if VECTOR does not have
a fill pointer.
------------------------------------------------------------------------------
FIND [Function]
Args: (item sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
Returns the first element in SEQUENCE satisfying TEST with ITEM.
------------------------------------------------------------------------------
KCL Dictionary Page 34
------------------------------------------------------------------------------
FIND-ALL-SYMBOLS [Function]
Args: (string-or-symbol)
Returns a list of all symbols in the system having the specified name.
------------------------------------------------------------------------------
FIND-IF [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL if
no such element exists.
------------------------------------------------------------------------------
FIND-IF-NOT [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the index of the first element in SEQUENCE that does not satisfy
TEST; NIL if no such element exists.
------------------------------------------------------------------------------
FIND-PACKAGE [Function]
Args: (name)
Returns the specified package if it already exists; NIL otherwise. NAME may
be a string that is the name or nickname of the package. NAME may also be
a symbol, in which case the symbol's print name is used.
------------------------------------------------------------------------------
FIND-SYMBOL [Function]
Args: (name &optional (package *package*))
Returns the symbol named NAME in PACKAGE. If such a symbol is found, then
the second value is :INTERN, :EXTERNAL, or :INHERITED to indicate how the
symbol is accessible. If no symbol is found then both values are NIL.
------------------------------------------------------------------------------
FINISH-OUTPUT [Function]
Args: (&optional (stream *standard-output*))
Attempts to ensure that all output sent to STREAM has reached its destination,
and only then returns.
------------------------------------------------------------------------------
FIRST [Function]
Args: (x)
Equivalent to (CAR X).
------------------------------------------------------------------------------
FIXNUM [Type]
A fixnum is an integer between MOST-NEGATIVE-FIXNUM (= -2147483648) and
MOST-POSITIVE-FIXNUM (= 2147483647), inclusive. Other integers are bignums.
------------------------------------------------------------------------------
FLET [Special form]
Syntax: (flet ({(name lambda-list {decl | doc}* {form}*)}*) . body)
Evaluates BODY as a PROGN, with the local function definitions in effect.
The scope of the locally defined functions does not include the function
definitions themselves, so they can reference externally defined functions
of the same name. See the doc of DEFUN for the complete syntax of a lambda-
list. Doc-strings for local functions are simply ignored.
------------------------------------------------------------------------------
KCL Dictionary Page 35
------------------------------------------------------------------------------
FLOAT [Type]
KCL supports two kinds of floating-point numbers. One kind is called
short-float and the other kind is called single-float, double-float, or
long-float. Precisions and exponent sizes of floating-point numbers depends
on the version of KCL. See the KCL Report at your hand for details.
The following syntax is used to denote a floating-point number.
{ [sign] {radix-10-digit}* decimal-point {radix-10-digit}+ [exponent]
| [sign] {radix-10-digit}+ [decimal-point {radix-10-digit}*}] exponent
}
where EXPONENT is
{ e | s | f | d | l | E | S | F | D | L } [sign] {radix-10-digit}+
See the type doc of INTEGER for the syntactic variables used here. The
exponent markers in EXPONENT have the following interpretations.
e or E floating-point number in the default float format
s or S short-float
f or F single-float
d or D double-float
l or L long-float
The default float format is single-float normally, but may be any other float
format. See the variable doc of *READ-DEFAULT-FLOAT-FORMAT*.
------------------------------------------------------------------------------
FLOAT [Function]
Args: (number &optional (other nil))
Converts a number of any type to floating point.
If OTHER is not provided, it returns a SINGLE-FLOAT if NUMBER
is not already a FLOAT. If OTHER is provided, the result is
the same float format as OTHER.
------------------------------------------------------------------------------
FLOAT-DIGITS [Function]
Args: (float)
Returns the number of the radix digits used to represent the floating-point
number FLOAT.
------------------------------------------------------------------------------
FLOAT-PRECISION [Function]
Args: (float)
Returns the number of the significant radix digits used to represent the
floating-point number FLOAT.
------------------------------------------------------------------------------
FLOAT-RADIX [Function]
Args: (float)
Returns the radix of the floating-point number FLOAT.
------------------------------------------------------------------------------
FLOAT-SIGN [Function]
Args: (float1 &optional (float2 (float 1 float1)))
Returns a floating-point number with the same sign as FLOAT1 and with the
same absolute value as FLOAT2.
------------------------------------------------------------------------------
FLOATP [Function]
Args: (x)
Returns T if X is a floating-point number; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 36
------------------------------------------------------------------------------
FLOOR [Function]
Args: (number &optional (divisor 1))
Returns the greatest integer not greater than NUMBER/DIVISOR. The second
returned value is (MOD NUMBER DIVISOR).
------------------------------------------------------------------------------
FMAKUNBOUND [Function]
Args: (symbol)
Causes the global function definition named by SYMBOL to become unbound.
Returns SYMBOL.
------------------------------------------------------------------------------
FORCE-OUTPUT [Function]
Args: (&optional (stream *standard-output*))
Attempts to force any buffered output to be sent.
------------------------------------------------------------------------------
FORMAT [Function]
Args: (destination control-string &rest arguments)
Provides various facilities for formatting output. CONTROL-STRING is a string
to be output, possibly with embedded formatting directives, which are flagged
with the escape character "~". Directives generally expand into additional
text to be output, usually consuming one or more of ARGUMENTs in the process.
A few useful directives are:
~A, ~nA, ~n@A Prints one argument as if by PRINC
~S, ~nS, ~n@S Prints one argument as if by PRIN1
~D, ~B, ~O, ~X Prints one integer in decimal, binary, octal, and hexa
~% Does TERPRI
~& Does FRESH-LINE
where n is the minimal width of the field in which the object is printed.
~nA and ~nS put padding spaces on the right; ~n@A and ~n@S put on the left.
DESTINATION controls where the result will go. If DESTINATION is T, then
the output is sent to the standard output stream. If it is NIL, then the
output is returned in a string as the value of the call. Otherwise,
DESTINATION must be a stream to which the output will be sent.
------------------------------------------------------------------------------
FOURTH [Function]
Args: (x)
Equivalent to (CADDDR X).
------------------------------------------------------------------------------
FRESH-LINE [Function]
Args: (&optional (stream *standard-output*))
Outputs a newline if it is not positioned at the beginning of a line. Returns
T if it output a newline; NIL otherwise.
------------------------------------------------------------------------------
FROUND [Function]
Args: (number &optional (divisor 1))
Same as ROUND, but returns first value as a float.
------------------------------------------------------------------------------
KCL Dictionary Page 37
------------------------------------------------------------------------------
FTRUNCATE [Function]
Args: (number &optional (divisor 1))
Same as TRUNCATE, but returns first value as a float.
------------------------------------------------------------------------------
FUNCALL [Function]
Args: (function &rest arguments)
Applies FUNCTION to the ARGUMENTs
------------------------------------------------------------------------------
FUNCTION [Type]
A function is anything that may be correctly given to the FUNCALL or APPLY
function, and is to be executed as code when arguments are supplied.
A function is either:
* a compiled function (compiled-function or compiled-closure)
* a list in one of the following format.
(lambda lambda-list . body)
(lambda-block block-name lambda-list . body)
(lambda-closure env1 env2 env3 lambda-list . body)
(lambda-block-closure env1 env2 env3 block-name lambda-list . body)
where env1, env2, and env3 respectively represent the variable
environment, the function/macro environment, and the block/tagbody
environment at the time of the function creation.
* a symbol that names a function.
See the doc of DEFUN for the complete syntax of a lambda-list.
------------------------------------------------------------------------------
FUNCTION [Special form]
Syntax: (function x) or #'x
If X is a lambda expression, creates and returns a lexical closure of X in
the current lexical environment. If X is a symbol that names a function,
returns that function.
------------------------------------------------------------------------------
FUNCTIONP [Function]
Args: (x)
Returns T if X is a function, suitable for use by FUNCALL or APPLY. Returns
NIL otherwise.
------------------------------------------------------------------------------
GBC [Function]
Args: (x)
KCL specific: Invokes the garbage collector (GC) with the collection level
specified by X. NIL as the argument causes GC to collect cells only. T as
the argument causes GC to collect everything.
------------------------------------------------------------------------------
GCD [Function]
Args: (&rest integers)
Returns the greatest common divisor of INTEGERs.
------------------------------------------------------------------------------
GENSYM [Function]
Args: (&optional (x nil))
Creates and returns a new uninterned symbol whose name is a prefix string
(defaults to "G"), followed by a decimal number. The number is incremented
by each call to GENSYM. X, if an integer, resets the counter. If X is a
string, it becomes the new prefix.
------------------------------------------------------------------------------
KCL Dictionary Page 38
------------------------------------------------------------------------------
GENTEMP [Function]
Args: (&optional (prefix "t") (package *package*))
Creates a new symbol interned in the package PACKAGE with the given PREFIX.
------------------------------------------------------------------------------
GET [Function]
Args: (symbol indicator &optional (default nil))
Looks on the property list of SYMBOL for the specified INDICATOR. If this
is found, returns the associated value. Otherwise, returns DEFAULT.
------------------------------------------------------------------------------
GET-DECODED-TIME [Function]
Args: ()
Returns the current time in decoded time format. Returns nine values: second,
minute, hour, date, month, year, day-of-week, daylight-saving-time-p, and
time-zone.
------------------------------------------------------------------------------
GET-DISPATCH-MACRO-CHARACTER [Function]
Args: (disp-char sub-char &optional (readtable *readtable*))
Returns the macro-character function for SUB-CHAR under DISP-CHAR.
------------------------------------------------------------------------------
GET-INTERNAL-REAL-TIME [Function]
Args: ()
Returns the real time in the internal time format. This is useful for
finding elapsed time.
------------------------------------------------------------------------------
GET-INTERNAL-RUN-TIME [Function]
Args: ()
Returns the run time in the internal time format. This is useful for
finding CPU usage.
------------------------------------------------------------------------------
GET-MACRO-CHARACTER [Function]
Args: (char &optional (readtable *readtable*))
Returns the function associated with CHAR and, as a second value, returns
the non-terminating-p flag.
------------------------------------------------------------------------------
GET-OUTPUT-STREAM-STRING [Function]
Args: (stream)
Returns a string of all the characters sent to STREAM made by
MAKE-STRING-OUTPUT-STREAM since the last call to this function.
------------------------------------------------------------------------------
GET-PROPERTIES [Function]
Args: (place indicator-list)
Looks for the elements of INDICATOR-LIST in the property list stored in PLACE.
If found, returns the indicator, the value, and T as multiple-values. If not,
returns NILs as its three values.
------------------------------------------------------------------------------
KCL Dictionary Page 39
------------------------------------------------------------------------------
GET-SETF-METHOD [Function]
Args: (form)
Returns the five values (or five 'gangs') constituting the SETF method for
FORM. See the doc of DEFINE-SETF-METHOD for the meanings of the gangs. It
is an error if the third value (i.e., the list of store variables) is not a
one-element list. See the doc of GET-SETF-METHOD-MULTIPLE-VALUE for
comparison.
------------------------------------------------------------------------------
GET-SETF-METHOD-MULTIPLE-VALUE [Function]
Args: (form)
Returns the five values (or five 'gangs') constituting the SETF method for
FORM. See the doc of DEFINE-SETF-METHOD for the meanings of the gangs. The
third value (i.e., the list of store variables) may consist of any number of
elements. See the doc of GET-SETF-METHOD for comparison.
------------------------------------------------------------------------------
GET-UNIVERSAL-TIME [Function]
Args: ()
Returns the current time as a single integer in universal time format.
------------------------------------------------------------------------------
GETF [Function]
Args: (place indicator &optional (default nil))
Searches the property list stored in Place for an indicator EQ to Indicator.
If one is found, the corresponding value is returned, else the Default is
returned.
------------------------------------------------------------------------------
GETHASH [Function]
Args: (key hash-table &optional (default nil))
Finds the entry in HASH-TABLE whose key is KEY and returns the associated
value and T, as multiple values. Returns DEFAULT and NIL if there is no
such entry.
------------------------------------------------------------------------------
GO [Special form]
Syntax: (go tag)
Jumps to the specified TAG established by a lexically surrounding TAGBODY.
------------------------------------------------------------------------------
GRAPHIC-CHAR-P [Function]
Args: (char)
Returns T if CHAR is a printing character, i.e., #\Space through #\~;
NIL otherwise.
------------------------------------------------------------------------------
HASH-TABLE [Type]
Hash tables provide an efficient way of mapping any Lisp object to an
associated object.
A hash table is denoted as #<a hash-table>.
------------------------------------------------------------------------------
HASH-TABLE-COUNT [Function]
Args: (hash-table)
Returns the number of entries in the given Hash-Table.
------------------------------------------------------------------------------
KCL Dictionary Page 40
------------------------------------------------------------------------------
HASH-TABLE-P [Function]
Args: (x)
Returns T if X is a hash table object; NIL otherwise.
------------------------------------------------------------------------------
HELP [Function]
Args: (&optional symbol)
KCL specific: Prints the documentation associated with SYMBOL. With no
argument, this function prints the greeting message to KCL beginners.
------------------------------------------------------------------------------
HELP* [Function]
Args: (string &optional (package 'lisp))
KCL specific: Prints the documentation associated with those symbols in the
specified package whose print names contain STRING as substring. STRING may
be a symbol, in which case the print-name of that symbol is used. If PACKAGE
is NIL, then all packages are searched.
------------------------------------------------------------------------------
HOST-NAMESTRING [Function]
Args: (pathname)
Returns the host part of PATHNAME as a string.
------------------------------------------------------------------------------
IDENTITY [Function]
Args: (x)
Simply returns X.
------------------------------------------------------------------------------
IF [Special form]
Syntax: (if test then [else])
If TEST evaluates to non-NIL, then evaluates THEN and returns the result.
If not, evaluates ELSE (which defaults to NIL) and returns the result.
------------------------------------------------------------------------------
*IGNORE-MAXIMUM-PAGES* [Variable]
KCL specific: Tells the KCL memory manager whether (non-NIL) or not (NIL) it
should expand memory whenever the maximum allocatable pages have been used
up.
------------------------------------------------------------------------------
IMAGPART [Function]
Args: (number)
Extracts the imaginary part of NUMBER.
------------------------------------------------------------------------------
IMPORT [Function]
Args: (symbols &optional (package *package*))
Makes SYMBOLS available as internal symbols in PACKAGE. If a symbol is
already available then it has no effect. If a name conflict would result
from the importation, then a correctable error is signalled. SYMBOLS must
be a list of symbols or a symbol.
------------------------------------------------------------------------------
KCL Dictionary Page 41
------------------------------------------------------------------------------
IN-PACKAGE [Function]
Args: (package-name &key (nicknames nil) (use '(lisp)))
Sets *PACKAGE* to the package with PACKAGE-NAME, creating the package if
it does not exist. If the package already exists then it is modified
to agree with USE and NICKNAMES arguments. Any new nicknames are added
without removing any old ones not specified. If any package in the USE list
is not currently used, then it is added to the use list.
------------------------------------------------------------------------------
INCF [Macro]
Syntax: (incf place [delta])
Adds the number produced by DELTA (which defaults to 1) to the number
in PLACE.
------------------------------------------------------------------------------
INPUT-STREAM-P [Function]
Args: (stream)
Returns non-NIL if STREAM can handle input operations; NIL otherwise.
------------------------------------------------------------------------------
INSPECT [Function]
Args: (x)
Shows the information about the object X in an interactive manner
------------------------------------------------------------------------------
INT-CHAR [Function]
Args: (integer)
Performs the inverse of CHAR-INT. Equivalent to CODE-CHAR in KCL.
------------------------------------------------------------------------------
INTEGER [Type]
An integer represents a mathematical integer. An integer may be a fixnum, or
else it is a bignum. Normally, the following syntax is used to denote an
integer:
{ [sign]{digit-in-default-radix}+
| {#b | #B} [sign] {radix-2-digit}+
| {#o | #O} [sign] {radix-8-digit}+
| [sign] {radix-10-digit}+ decimal-point
| {#x | #X} [sign] {radix-16-digit}+
| {#2r | #2R} [sign] {radix-2-digit}+
....
| {#36r | #36R} [sign] {radix-36-digit}+ }
where SIGN is either '+' or '-', DECIMAL-POINT is '.', and
digit-in-radix-2 ::= { 0 | 1 }
...
digit-in-radix-10 ::= { 0 | 1 | ... | 9 }
digit-in-radix-11 ::= { 0 | 1 | ... | 9 | a | A }
...
digit-in-radix-36 ::= { 0 | 1 | ... | 9 | a | ... | z | A | ... | Z }
The default radix is 10 normally, but may be any integer between 2 and 36
inclusive. See the variable docs of *PRINT-RADIX* and *READ-BASE*.
------------------------------------------------------------------------------
INTEGER-DECODE-FLOAT [Function]
Args: (float)
Returns as an integer the significand of the floating-point number.
------------------------------------------------------------------------------
KCL Dictionary Page 42
------------------------------------------------------------------------------
INTEGER-LENGTH [Function]
Args: (integer)
Returns the number of significant bits in the absolute value of INTEGER.
------------------------------------------------------------------------------
INTEGERP [Function]
Args: (x)
Returns T if X is an integer (fixnum or bignum); NIL otherwise.
------------------------------------------------------------------------------
INTERN [Function]
Args: (name &optional (package *package*))
Returns a symbol having the specified name, creating it if necessary.
Returns as the second value one of the symbols :INTERNAL, :EXTERNAL,
:INHERITED, and NIL.
------------------------------------------------------------------------------
INTERNAL-TIME-UNITS-PER-SECOND [Constant]
The number of internal time units that fit into a second.
------------------------------------------------------------------------------
INTERSECTION [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the intersection of List1 and List2.
------------------------------------------------------------------------------
ISQRT [Function]
Args: (integer)
Returns the greatest integer less than or equal to the square root of the
given non-negative integer.
------------------------------------------------------------------------------
KEYWORDP [Function]
Args: (x)
Returns T if X is a symbol and it belongs to the KEYWORD package; NIL
otherwise.
------------------------------------------------------------------------------
LABELS [Special form]
Syntax: (labels ({(name lambda-list {decl | doc}* {form}*)}*) . body)
Evaluates BODY as a PROGN, with the local function definitions in effect.
The scope of the locally defined functions include the function definitions
themselves, so they can reference externally defined functions of the same
name. See the doc of DEFUN for the complete syntax of a lambda-list.
Doc-strings for local functions are simply ignored.
------------------------------------------------------------------------------
LAMBDA-LIST-KEYWORDS [Constant]
List of all the lambda-list keywords used in KCL.
------------------------------------------------------------------------------
LAMBDA-PARAMETERS-LIMIT [Constant]
The exclusive upper bound on the number of distinct parameter names that may
appear in a single lambda-list. Actually, however, there is no such upper
bound in KCL.
------------------------------------------------------------------------------
KCL Dictionary Page 43
------------------------------------------------------------------------------
LAST [Function]
Args: (list)
Returns the last cons in LIST
------------------------------------------------------------------------------
LAST-TERMINATION-MESSAGE [Function]
Args: ()
KCL specific: Flushes all the message currently spooled and returns the last
termination message as a string. Only KCL/AOS supports this function.
------------------------------------------------------------------------------
LCM [Function]
Args: (integer &rest more-integers)
Returns the least common multiple of the arguments.
------------------------------------------------------------------------------
LDB [Function]
Args: (bytespec integer)
Extracts the specified byte from INTEGER, and right justifies the result.
------------------------------------------------------------------------------
LDB-TEST [Function]
Args: (bytespec integer)
Returns T if any of the specified bits in INTEGER are 1.
------------------------------------------------------------------------------
LDIFF [Function]
Args: (list sublist)
Returns a new list, whose elements are those of LIST that appear before
SUBLIST. If SUBLIST is not a tail of LIST, a copy of LIST is returned.
------------------------------------------------------------------------------
LEAST-NEGATIVE-DOUBLE-FLOAT [Constant]
Same as LEAST-NEGATIVE-LONG-FLOAT.
------------------------------------------------------------------------------
LEAST-NEGATIVE-LONG-FLOAT [Constant]
The negative long-float closest in value to zero.
------------------------------------------------------------------------------
LEAST-NEGATIVE-SHORT-FLOAT [Constant]
The negative short-float closest in value to zero.
------------------------------------------------------------------------------
LEAST-NEGATIVE-SINGLE-FLOAT [Constant]
Same as LEAST-NEGATIVE-LONG-FLOAT.
------------------------------------------------------------------------------
LEAST-POSITIVE-DOUBLE-FLOAT [Constant]
Same as LEAST-POSITIVE-LONG-FLOAT.
------------------------------------------------------------------------------
LEAST-POSITIVE-LONG-FLOAT [Constant]
The positive long-float closest in value to zero.
------------------------------------------------------------------------------
LEAST-POSITIVE-SHORT-FLOAT [Constant]
The positive short-float closest in value to zero.
------------------------------------------------------------------------------
KCL Dictionary Page 44
------------------------------------------------------------------------------
LEAST-POSITIVE-SINGLE-FLOAT [Constant]
Same as LEAST-POSITIVE-LONG-FLOAT.
------------------------------------------------------------------------------
LENGTH [Function]
Args: (sequence)
Returns the length of SEQUENCE.
------------------------------------------------------------------------------
LET [Special form]
Syntax: (let ({var | (var [value])}*) {decl}* {form}*)
Initializes VARs, binding them to the values of VALUEs (which defaults to NIL)
all at once, then evaluates FORMs as a PROGN.
------------------------------------------------------------------------------
LET* [Special form]
Syntax: (let* ({var | (var [value])}*) {decl}* {form}*)
Initializes VARs, binding them to the values of VALUEs (which defaults to NIL)
from left to right, then evaluates FORMs as a PROGN.
------------------------------------------------------------------------------
LISP-IMPLEMENTATION-TYPE [Function]
Args: ()
Returns a string that tells you that you are using a version of KCL.
------------------------------------------------------------------------------
LISP-IMPLEMENTATION-VERSION [Function]
Args: ()
Returns a string that tells you when the current KCL implementation is
brought up.
------------------------------------------------------------------------------
LIST [Type]
A list is either NIL (the empty list) or a cons whose cdr is a list.
A list is denoted by writing its element in order, separated by blank space,
and surrounded by parentheses.
A dotted list is a cons whose cdr is either a non-cons object or a dotted
list. A dotted list is denoted in the same way as a list is, but the last
cdr in the cdr chain is preceded by a dot '.' and blank space.
The backquote macro is sometimes useful to construct a compilcated list
structure. When evaluating `(...)
,form embeds the value of FORM,
,@form and ,.form embed all elements of the list value of FORM,
and other things embed itself
into the structure at their position. For example,
`(a b ,c d e) expands to (list* 'a 'b c '(d e))
`(a b ,@c d e) expands to (list* 'a 'b (append c '(d e)))
`(a b ,.c d e) expands to (list* 'a 'b (nconc c '(d e)))
------------------------------------------------------------------------------
LIST [Function]
Args: (&rest args)
Returns a list of its arguments
------------------------------------------------------------------------------
KCL Dictionary Page 45
------------------------------------------------------------------------------
LIST* [Function]
Args: (arg &rest others)
Returns a list of its arguments with the last cons being a dotted pair of
the next to the last argument and the last argument.
------------------------------------------------------------------------------
LIST-ALL-PACKAGES [Function]
Args: ()
Returns a list of all existing packages.
------------------------------------------------------------------------------
LIST-LENGTH [Function]
Args: (list)
Returns the length of LIST, or NIL if LIST is circular.
------------------------------------------------------------------------------
LISTEN [Function]
Args: (&optional (stream *standard-input*))
Returns T if a character is available on STREAM; NIL otherwise. This function
does not correctly work in some versions of KCL because of the lack of such
mechanism in the underlying operating system.
------------------------------------------------------------------------------
LISTP [Function]
Args: (x)
Returns T if X is either a cons or NIL; NIL otherwise.
------------------------------------------------------------------------------
LOAD [Function]
Args: (filename
&key (verbose *load-verbose*) (print nil) (if-does-not-exist :error))
Loads the file named by FILENAME into KCL.
------------------------------------------------------------------------------
*LOAD-VERBOSE* [Variable]
The default for the VERBOSE argument to LOAD.
------------------------------------------------------------------------------
LOCALLY [Macro]
Syntax: (locally {decl}* {form}*)
Gives local pervasive declarations.
------------------------------------------------------------------------------
LOG [Function]
Args: (number &optional base)
Returns the logarithm of NUMBER in the base BASE. BASE defaults to the base
of natural logarithms.
------------------------------------------------------------------------------
LOGAND [Function]
Args: (&rest integers)
Returns the bit-wise AND of its arguments.
------------------------------------------------------------------------------
LOGANDC1 [Function]
Args: (integer1 integer2)
Returns the logical AND of (LOGNOT INTEGER1) and INTEGER2.
------------------------------------------------------------------------------
KCL Dictionary Page 46
------------------------------------------------------------------------------
LOGANDC2 [Function]
Args: (integer1 integer2)
Returns the logical AND of INTEGER1 and (LOGNOT INTEGER2).
------------------------------------------------------------------------------
LOGBITP [Function]
Args: (index integer)
Returns T if the INDEX-th bit of INTEGER is 1.
------------------------------------------------------------------------------
LOGCOUNT [Function]
Args: (integer)
If INTEGER is negative, returns the number of 0 bits. Otherwise, returns
the number of 1 bits.
------------------------------------------------------------------------------
LOGEQV [Function]
Args: (&rest integers)
Returns the bit-wise EQUIVALENCE of its arguments.
------------------------------------------------------------------------------
LOGIOR [Function]
Args: (&rest integers)
Returns the bit-wise INCLUSIVE OR of its arguments.
------------------------------------------------------------------------------
LOGNAND [Function]
Args: (integer1 integer2)
Returns the complement of the logical AND of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
LOGNOR [Function]
Args: (integer1 integer2)
Returns the complement of the logical OR of INTEGER1 and INTEGER2.
------------------------------------------------------------------------------
LOGNOT [Function]
Args: (integer)
Returns the bit-wise logical NOT of INTEGER.
------------------------------------------------------------------------------
LOGORC1 [Function]
Args: (integer1 integer2)
Returns the logical OR of (LOGNOT INTEGER1) and INTEGER2.
------------------------------------------------------------------------------
LOGORC2 [Function]
Args: (integer1 integer2)
Returns the logical OR of INTEGER1 and (LOGNOT INTEGER2).
------------------------------------------------------------------------------
LOGTEST [Function]
Args: (integer1 integer2)
Returns T if LOGAND of INTEGER1 and INTEGER2 is not zero; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 47
------------------------------------------------------------------------------
LOGXOR [Function]
Args: (&rest integers)
Returns the bit-wise EXCLUSIVE OR of its arguments.
------------------------------------------------------------------------------
LONG-FLOAT-EPSILON [Constant]
The smallest positive long-float that satisfies
(not (= (float 1 e) (+ (float 1 e) e))).
------------------------------------------------------------------------------
LONG-FLOAT-NEGATIVE-EPSILON [Constant]
The smallest positive long-float that satisfies
(not (= (float 1 e) (- (float 1 e) e))).
------------------------------------------------------------------------------
LONG-SITE-NAME [Function]
Args: ()
Returns a string that identifies the physical location of the current KCL.
------------------------------------------------------------------------------
LOOP [Macro]
Syntax: (loop {form}*)
Executes FORMs repeatedly until exited by a THROW or RETURN. The FORMs are
surrounded by an implicit NIL block.
------------------------------------------------------------------------------
LOWER-CASE-P [Function]
Args: (char)
Returns T if CHAR is a lower-case character; NIL otherwise.
------------------------------------------------------------------------------
MACHINE-INSTANCE [Function]
Args: ()
Returns a string that identifies the machine instance of the machine
on which KCL is currently running.
------------------------------------------------------------------------------
MACHINE-TYPE [Function]
Args: ()
Returns a string that identifies the machine type of the machine
on which KCL is currently running.
------------------------------------------------------------------------------
MACHINE-VERSION [Function]
Args: ()
Returns a string that identifies the machine version of the machine
on which KCL is currently running.
------------------------------------------------------------------------------
MACRO-FUNCTION [Function]
Args: (symbol)
If SYMBOL globally names a macro, then returns the expansion function.
Returns NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 48
------------------------------------------------------------------------------
MACROEXPAND [Function]
Args: (form &optional (env nil))
If FORM is a macro form, then expands it repeatedly until it is not a macro
any more. Returns two values: the expanded form and a T-or-NIL flag
indicating whether the original form was a macro.
------------------------------------------------------------------------------
MACROEXPAND-1 [Function]
Args: (form &optional (env nil))
If FORM is a macro form, then expands it once. Returns two values: the
expanded form and a T-or-NIL flag indicating whether the original form was
a macro.
------------------------------------------------------------------------------
*MACROEXPAND-HOOK* [Variable]
Holds a function that can take two arguments (a macro expansion function
and the macro form to be expanded) and returns the expanded form. This
function is whenever a macro-expansion takes place. Initially this is set to
#'FUNCALL.
------------------------------------------------------------------------------
MACROLET [Special form]
Syntax: (macrolet ({(name defmacro-lambda-list {decl | doc}* . body)}*)
{form}*)
Evaluates FORMs as a PROGN, with the local macro definitions in effect.
See the doc of DEFMACRO for the complete syntax of a defmacro-lambda-list.
Doc-strings for local macros are simply ignored.
------------------------------------------------------------------------------
MAKE-ARRAY [Function]
Args: (dimensions
&key (element-type t) initial-element (initial-contents nil)
(adjustable nil) (fill-pointer nil) (displaced-to nil)
(displaced-index-offset 0))
Creates an array of the specified DIMENSIONS. The default for INITIAL-
ELEMENT depends on ELEMENT-TYPE.
------------------------------------------------------------------------------
MAKE-BROADCAST-STREAM [Function]
Args: (&rest streams)
Returns an output stream which sends its output to all of the given streams.
------------------------------------------------------------------------------
MAKE-CHAR [Function]
Args: (char &optional (bits 0) (font 0))
Returns a character object with the same code attribute as CHAR and with
the specified BITS and FONT attributes.
------------------------------------------------------------------------------
MAKE-CONCATENATED-STREAM [Function]
Args: (&rest streams)
Returns a stream which takes its input from each of the STREAMs in turn,
going on to the next at end of stream.
------------------------------------------------------------------------------
MAKE-DISPATCH-MACRO-CHARACTER [Function]
Args: (char &optional (non-terminating-p nil) (readtable *readtable*))
Causes the character CHAR to be a dispatching macro character in READTABLE.
------------------------------------------------------------------------------
KCL Dictionary Page 49
------------------------------------------------------------------------------
MAKE-ECHO-STREAM [Function]
Args: (input-stream output-stream)
Returns a bidirectional stream which gets its input from INPUT-STREAM and
sends its output to OUTPUT-STREAM. In addition, all input is echoed to
OUTPUT-STREAM.
------------------------------------------------------------------------------
MAKE-HASH-TABLE [Function]
Args: (&key (test 'eql) (size 1024) (rehash-size 1.5) (rehash-threshold 0.7))
Creates and returns a hash table.
------------------------------------------------------------------------------
MAKE-LIST [Function]
Args: (size &key (initial-element nil))
Creates and returns a list containing SIZE elements, each of which is
initialized to INITIAL-ELEMENT.
------------------------------------------------------------------------------
MAKE-PACKAGE [Function]
Args: (package-name &key (nicknames nil) (use '(lisp)))
Makes a new package having the specified PACKAGE-NAME and NICKNAMES. The
package will inherit all external symbols from each package in the USE list.
------------------------------------------------------------------------------
MAKE-PATHNAME [Function]
Args: (&key (defaults *make-pathname-default-pathname*)
(host (pathname-host defaults))
(device (pathname-device defaults))
(directory (pathname-directory defaults))
(name (pathname-name defaults))
(type (pathname-type defaults))
(version (pathname-version defaults)))
Create a pathname from HOST, DEVICE, DIRECTORY, NAME, TYPE and VERSION.
------------------------------------------------------------------------------
MAKE-RANDOM-STATE [Function]
Args: (&optional (state *random-state*))
Creates and returns a copy of the specified random state. If STATE is NIL,
then the value of *RANDOM-STATE* is used. If STATE is T, then returns a
random state object generated from the universal time.
------------------------------------------------------------------------------
MAKE-SEQUENCE [Function]
Args: (type length &key initial-element)
Returns a sequence of the given TYPE and LENGTH, with elements initialized
to INITIAL-ELEMENT. The default value of INITIAL-ELEMENT depends on TYPE.
------------------------------------------------------------------------------
MAKE-STRING [Function]
Args: (size &key (initial-element #\Space))
Creates and returns a new string of SIZE length whose elements are all
INITIAL-ELEMENT.
------------------------------------------------------------------------------
MAKE-STRING-INPUT-STREAM [Function]
Args: (string &optional (start 0) (end (length string)))
Returns an input stream which will supply the characters of String between
Start and End in order.
------------------------------------------------------------------------------
KCL Dictionary Page 50
------------------------------------------------------------------------------
MAKE-STRING-OUTPUT-STREAM [Function]
Args: ()
Returns an output stream which will accumulate all output given it for
the benefit of the function GET-OUTPUT-STREAM-STRING.
------------------------------------------------------------------------------
MAKE-SYMBOL [Function]
Args: (string)
Creates and returns a new uninterned symbol whose print name is STRING.
------------------------------------------------------------------------------
MAKE-SYNONYM-STREAM [Function]
Args: (symbol)
Returns a stream which performs its operations on the stream which is the
value of the dynamic variable named by SYMBOL.
------------------------------------------------------------------------------
MAKE-TWO-WAY-STREAM [Function]
Args: (input-stream output-stream)
Returns a bidirectional stream which gets its input from INPUT-STREAM and
sends its output to OUTPUT-STREAM.
------------------------------------------------------------------------------
MAKUNBOUND [Function]
Args: (symbol)
Causes the dynamic variable named by SYMBOL to have not value. Returns
SYMBOL.
------------------------------------------------------------------------------
MAP [Function]
Args: (result-type function sequence &rest more-sequences)
FUNCTION must take as many arguments as there are sequences provided. The
result is a sequence such that the i-th element is the result of applying
FUNCTION to the i-th elements of the SEQUENCEs.
------------------------------------------------------------------------------
MAPC [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs. Returns the first LIST.
------------------------------------------------------------------------------
MAPCAN [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs, NCONCs the results, and returns it.
------------------------------------------------------------------------------
MAPCAR [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cars of LISTs and returns the results as a list.
------------------------------------------------------------------------------
MAPCON [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs, NCONCs the results, and returns it.
------------------------------------------------------------------------------
KCL Dictionary Page 51
------------------------------------------------------------------------------
MAPHASH [Function]
Args: #'hash-table
For each entry in HASH-TABLE, calls FUNCTION on the key and value of the
entry; returns NIL.
------------------------------------------------------------------------------
MAPL [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs. Returns the first LIST.
------------------------------------------------------------------------------
MAPLIST [Function]
Args: (fun list &rest more-lists)
Applies FUN to successive cdrs of LISTs and returns the results as a list.
------------------------------------------------------------------------------
MASK-FIELD [Function]
Args: (bytespec integer)
Extracts the specified byte from INTEGER, without right justification.
------------------------------------------------------------------------------
MAX [Function]
Args: (number &rest more-numbers)
Returns the greatest of its arguments.
------------------------------------------------------------------------------
MAXIMUM-ALLOCATABLE-PAGES [Function]
Args: (type)
KCL specific: Returns the current maximum number of pages for the type class
of the KCL implementation type TYPE.
------------------------------------------------------------------------------
MAXIMUM-CONTIGUOUS-PAGES [Function]
Args: ()
KCL specific: Returns the current maximum number of pages for contiguous
blocks.
------------------------------------------------------------------------------
MEMBER [Function]
Args: (item list &key (test #'eql) test-not (key #'identity))
Returns the tail of LIST beginning with the first ITEM.
------------------------------------------------------------------------------
MEMBER-IF [Function]
Args: (test list &key (key #'identity))
Returns the tail of LIST beginning with the first element satisfying TEST.
------------------------------------------------------------------------------
MEMBER-IF-NOT [Function]
Args: (test list &key (key #'identity))
Returns the tail of LIST beginning with the first element not satisfying
TEST.
------------------------------------------------------------------------------
MERGE [Function]
Args: (result-type sequence1 sequence2 predicate &key (key #'identity))
SEQUENCE1 and SEQUENCE2 are destructively merged into a sequence of type
RESULT-TYPE using PREDICATE to order the elements.
------------------------------------------------------------------------------
KCL Dictionary Page 52
------------------------------------------------------------------------------
MERGE-PATHNAMES [Function]
Args: (pathname
&optional (defaults *default-pathname-defaults*) default-version)
Fills in unspecified slots of PATHNAME from DEFAULTS. DEFAULT-VERSION
is ignored in KCL.
------------------------------------------------------------------------------
MIN [Function]
Args: (number &rest more-numbers)
Returns the least of its arguments.
------------------------------------------------------------------------------
MINUSP [Function]
Args: (number)
Returns T if NUMBER < 0; NIL otherwise.
------------------------------------------------------------------------------
MISMATCH [Function]
Args: (sequence1 sequence2
&key (from-end nil) (test #'eql) test-not (start1 0) (start2 0)
(end1 (length sequence1)) (end2 (length sequence2))
(key #'identity))
The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared
element-wise. If they are of equal length and match in every element, the
result is NIL. Otherwise, the result is a non-negative integer, the index
within SEQUENCE1 of the leftmost position at which they fail to match; or, if
one is shorter than and a matching prefix of the other, the index within
SEQUENCE1 beyond the last position tested is returned.
------------------------------------------------------------------------------
MOD [Function]
Args: (number divisor)
Returns the second result of (FLOOR NUMBER DIVISOR).
------------------------------------------------------------------------------
*MODULES* [Variable]
A list of names of the modules that have been loaded into KCL.
------------------------------------------------------------------------------
MOST-NEGATIVE-DOUBLE-FLOAT [Constant]
Same as MOST-NEGATIVE-LONG-FLOAT.
------------------------------------------------------------------------------
MOST-NEGATIVE-FIXNUM [Constant]
The fixnum closest in value to negative infinity.
------------------------------------------------------------------------------
MOST-NEGATIVE-LONG-FLOAT [Constant]
The long-float closest in value to negative infinity.
------------------------------------------------------------------------------
MOST-NEGATIVE-SHORT-FLOAT [Constant]
The short-float closest in value to negative infinity.
------------------------------------------------------------------------------
MOST-NEGATIVE-SINGLE-FLOAT [Constant]
Same as MOST-NEGATIVE-LONG-FLOAT.
------------------------------------------------------------------------------
KCL Dictionary Page 53
------------------------------------------------------------------------------
MOST-POSITIVE-DOUBLE-FLOAT [Constant]
Same as MOST-POSITIVE-LONG-FLOAT.
------------------------------------------------------------------------------
MOST-POSITIVE-FIXNUM [Constant]
The fixnum closest in value to positive infinity.
------------------------------------------------------------------------------
MOST-POSITIVE-LONG-FLOAT [Constant]
The long-float closest in value to positive infinity.
------------------------------------------------------------------------------
MOST-POSITIVE-SHORT-FLOAT [Constant]
The short-float closest in value to positive infinity.
------------------------------------------------------------------------------
MOST-POSITIVE-SINGLE-FLOAT [Constant]
Same as MOST-POSITIVE-LONG-FLOAT.
------------------------------------------------------------------------------
MULTIPLE-VALUE-BIND [Macro]
Syntax: (multiple-value-bind ({var}*) values-form {decl}* {form}*)
Binds the VARiables to the results of VALUES-FORM, in order (defaulting to
NIL) and evaluates FORMs in order.
------------------------------------------------------------------------------
MULTIPLE-VALUE-CALL [Special form]
Syntax: (multiple-value-call function {form}*)
Calls FUNCTION with all the values of FORMs as arguments.
------------------------------------------------------------------------------
MULTIPLE-VALUE-LIST [Macro]
Syntax: (multiple-value-list form)
Evaluates FORM, and returns a list of multiple values it returned.
------------------------------------------------------------------------------
MULTIPLE-VALUE-PROG1 [Special form]
Syntax: (multiple-value-prog1 form {form}*)
Evaluates the first FORM, saves all the values produced, then evaluates
the other FORMs. Returns the saved values.
------------------------------------------------------------------------------
MULTIPLE-VALUE-SETQ [Macro]
Syntax: (multiple-value-setq variables form)
Sets each variable in the list VARIABLES to the corresponding value of FORM.
Returns the value assigned to the first variable.
------------------------------------------------------------------------------
MULTIPLE-VALUES-LIMIT [Constant]
The exclusive upper bound on the number of values that may be returned from
a function. Actually, however, there is no such upper bound in KCL.
------------------------------------------------------------------------------
NAME-CHAR [Function]
Args: (name)
Given an argument acceptable to string,
Returns a character object whose name is NAME if one exists. Returns NIL
otherwise. NAME must be an object that can be coerced to a string.
------------------------------------------------------------------------------
KCL Dictionary Page 54
------------------------------------------------------------------------------
NAMESTRING [Function]
Args: (pathname)
Returns the full form of PATHNAME as a string.
------------------------------------------------------------------------------
NBUTLAST [Function]
Args: (list &optional (n 1))
Changes the cdr of the N+1 th cons from the end of the list LIST to NIL.
Returns the whole list.
------------------------------------------------------------------------------
NCONC [Function]
Args: (&rest lists)
Concatenates LISTs by destructively modifying them.
------------------------------------------------------------------------------
NIL [Type]
The type NIL is a subtype of every type. No object belongs to this type.
------------------------------------------------------------------------------
NIL [Constant]
Holds NIL.
------------------------------------------------------------------------------
NINTERSECTION [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the intersection of LIST1 and LIST2. LIST1 may be destroyed.
------------------------------------------------------------------------------
NINTH [Function]
Args: (x)
Equivalent to (CAR (CDDDDR (CDDDDR X))).
------------------------------------------------------------------------------
NOT [Function]
Args: (x)
Returns T if X is NIL; NIL otherwise.
------------------------------------------------------------------------------
NOTANY [Function]
Args: (predicate sequence &rest more-sequences)
PREDICATE is applied to 0-th elements of SEQUENCEs, then possibly to 1-st
elements, and so on. Returns NIL as soon as any invocation of PREDICATE
returns a non-NIL value, or T if the end of a sequence is reached.
------------------------------------------------------------------------------
NOTEVERY [Function]
Args: (predicate sequence &rest more-sequences)
PREDICATE is applied to 0-th elements of SEQUENCEs, then possibly to 1-st
elements, and so on. Returns T as soon as any invocation of PREDICATE
returns NIL, or NIL if every invocation returns non-NIL.
------------------------------------------------------------------------------
NRECONC [Function]
Args: (x y)
Equivalent to (NCONC (NREVERSE X) Y).
------------------------------------------------------------------------------
KCL Dictionary Page 55
------------------------------------------------------------------------------
NREVERSE [Function]
Args: (sequence)
Returns a sequence of the same elements as SEQUENCE but in reverse order.
SEQUENCE may be destroyed.
------------------------------------------------------------------------------
NSET-DIFFERENCE [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list of elements of LIST1 that do not appear in LIST2. LIST1 may
be destroyed.
------------------------------------------------------------------------------
NSET-EXCLUSIVE-OR [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list with elements which appear but once in LIST1 and LIST2.
------------------------------------------------------------------------------
NSTRING-CAPITALIZE [Function]
Args: (string &key (start 0) (end (length string)))
Returns STRING with the first character of each word converted to upper-case,
and remaining characters in the word converted to lower case.
------------------------------------------------------------------------------
NSTRING-DOWNCASE [Function]
Args: (string &key (start 0) (end (length string)))
Returns STRING with all upper case characters converted to lowercase.
------------------------------------------------------------------------------
NSTRING-UPCASE [Function]
Args: (string &key (start 0) (end (length string)))
Returns STRING with all lower case characters converted to uppercase.
------------------------------------------------------------------------------
NSUBLIS [Function]
Args: (alist tree &key (test #'eql) test-not (key #'identity))
Substitutes from ALIST for subtrees of TREE.
------------------------------------------------------------------------------
NSUBST [Function]
Args: (new old tree &key (test #'eql) test-not (key #'identity))
Substitutes NEW for subtrees in TREE that match OLD.
------------------------------------------------------------------------------
NSUBST-IF [Function]
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that satisfy TEST.
------------------------------------------------------------------------------
NSUBST-IF-NOT [Function]
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that do not satisfy TEST.
------------------------------------------------------------------------------
KCL Dictionary Page 56
------------------------------------------------------------------------------
NSUBSTITUTE [Function]
Args: (newitem olditem sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (count most-positive-fixnum)
(key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that OLDITEMs are replaced with NEWITEM. SEQUENCE may be destroyed.
------------------------------------------------------------------------------
NSUBSTITUTE-IF [Function]
Args: (new test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that all elements satisfying TEST are replaced with NEWITEM. SEQUENCE
may be destroyed.
------------------------------------------------------------------------------
NSUBSTITUTE-IF-NOT [Function]
Args: (new test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that all elements not satisfying TEST are replaced with NEWITEM.
SEQUENCE may be destroyed.
------------------------------------------------------------------------------
NTH [Function]
Args: (n list)
Returns the N-th element of LIST, where the car of LIST is the zeroth
element.
------------------------------------------------------------------------------
NTHCDR [Function]
Args: (n list)
Returns the result of performing the CDR operation N times on LIST.
------------------------------------------------------------------------------
NULL [Function]
Args: (x)
Returns T if X is NIL; NIL otherwise.
------------------------------------------------------------------------------
NUMBER [Type]
A number is either an integer, a ratio, a floating-point number, or a complex
number. Integers and ratios are collectively called rationals.
------------------------------------------------------------------------------
NUMBERP [Function]
Args: (x)
Returns T if X is any kind of number; NIL otherwise.
------------------------------------------------------------------------------
NUMERATOR [Function]
Args: (rational)
Returns as an integer the numerator of the given rational number.
------------------------------------------------------------------------------
KCL Dictionary Page 57
------------------------------------------------------------------------------
NUNION [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the union of LIST1 and LIST2. LIST1 and/or LIST2 may be destroyed.
------------------------------------------------------------------------------
ODDP [Function]
Args: (integer)
Returns T if INTEGER is odd; NIL otherwise.
------------------------------------------------------------------------------
OPEN [Function]
Args: (filename &key (direction :input) (element-type 'string-char)
(if-exists :error) (if-does-not-exist :error))
Opens the file specified by FILENAME, which may be a string, a pathname,
or a stream. Returns a stream for the open file.
Possible DIRECTION values are :INPUT, :OUTPUT, :IO and :PROBE.
Possible ELEMENT-TYPE values are STRING-CHAR, (UNSIGNED-BYTE n),
UNSIGNED-BYTE, (SIGNED-BYTE n), SIGNED-BYTE, CHARACTER, BIT, (MOD n), and
:DEFAULT.
Possible IF-EXISTS values are :ERROR, :NEW-VERSION, :RENAME,
:RENAME-AND-DELETE, :OVERWRITE, :APPEND, :SUPERSEDE, and NIL.
Possible IF-DOES-NOT-EXIST values are :ERROR, :CREATE, and NIL.
------------------------------------------------------------------------------
OR [Macro]
Syntax: (or {form}*)
Evaluates FORMs in order from left to right. If any FORM evaluates to
non-NIL, quits and returns that (single) value. If the last FORM is reached,
returns whatever values it returns.
------------------------------------------------------------------------------
OUTPUT-STREAM-P [Function]
Args: (stream)
Returns non-nil if STREAM can handle output operations; NIL otherwise.
------------------------------------------------------------------------------
PACKAGE [Type]
Packages are collections of symbols that serve as name spaces.
A package is denoted as #<? package> where '?' is actually the name of the
package.
KCL provides five built-in packages:
lisp symbols that names Common Lisp functions and variables.
user the standard package used by the user.
keyword the keyword package.
system symbols that names internal functions and variables.
Has nicknames SYS and SI.
compiler symbols that names functions and variables internally used
by the KCL compiler.
------------------------------------------------------------------------------
*PACKAGE* [Variable]
The current package.
------------------------------------------------------------------------------
PACKAGE-NAME [Function]
Args: (package)
Returns the string that names the specified PACKAGE.
------------------------------------------------------------------------------
KCL Dictionary Page 58
------------------------------------------------------------------------------
PACKAGE-NICKNAMES [Function]
Args: (package)
Returns as a list the nickname strings for the specified PACKAGE.
------------------------------------------------------------------------------
PACKAGE-SHADOWING-SYMBOLS [Function]
Args: (package)
Returns the list of symbols that have been declared as shadowing symbols
in PACKAGE.
------------------------------------------------------------------------------
PACKAGE-USE-LIST [Function]
Args: (package)
Returns the list of packages used by PACKAGE.
------------------------------------------------------------------------------
PACKAGE-USED-BY-LIST [Function]
Args: (package)
Returns the list of packages that use PACKAGE.
------------------------------------------------------------------------------
PACKAGEP [Function]
Args: (x)
Returns T if X is a package; NIL otherwise.
------------------------------------------------------------------------------
PAIRLIS [Function]
Args: (keys data &optional (alist nil))
Constructs an association list from KEYS and DATA adding to ALIST.
------------------------------------------------------------------------------
PARSE-INTEGER [Function]
Args: (string
&key (start 0) (end (length string)) (radix 10) (junk-allowed nil))
Parses STRING for an integer and returns it.
------------------------------------------------------------------------------
PARSE-NAMESTRING [Function]
Args: (thing &optional host (defaults *default-pathname-defaults*)
&key (start 0) (end (length thing)) (junk-allowed nil))
Parses a string representation of a pathname into a pathname. HOST
is ignored.
------------------------------------------------------------------------------
PATHNAME [Type]
Pathnames are the means by which a Lisp program can interface to an external
file system in a reasonably implementation-independent manner.
Among the six elements in a pathname described in Steele's manual,
HOST, DEVICE, and VERSION are meaningless in KCL, though they are harmless
at all.
A pathname is denoted as #"???" where '???' is actually some pathname
information. This depends on the version of KCL. Refer to the KCL report
at your hand for details.
------------------------------------------------------------------------------
PATHNAME [Function]
Args: (x)
Turns X into a pathname. X may be a string, symbol, stream, or pathname.
------------------------------------------------------------------------------
KCL Dictionary Page 59
------------------------------------------------------------------------------
PATHNAME-DEVICE [Function]
Args: (pathname)
Returns the device slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAME-DIRECTORY [Function]
Args: (pathname)
Returns the directory slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAME-HOST [Function]
Args: (pathname)
Returns the host slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAME-NAME [Function]
Args: (pathname)
Returns the name slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAME-TYPE [Function]
Args: (pathname)
Returns the type slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAME-VERSION [Function]
Args: (pathname)
Returns the version slot of PATHNAME.
------------------------------------------------------------------------------
PATHNAMEP [Function]
Args: (x)
Returns T if X is a pathname object; NIL otherwise.
------------------------------------------------------------------------------
PEEK-CHAR [Function]
Args: (&optional (peek-type nil) (stream *standard-input*) (eof-error-p t)
(eof-value nil) (recursive-p nil))
Peeks at the next character in the input stream STREAM.
------------------------------------------------------------------------------
PHASE [Function]
Args: (number)
Returns the angle part of the polar representation of a complex number.
For non-complex numbers, this is 0.
------------------------------------------------------------------------------
PI [Constant]
The floating-point number that is appropriately equal to the ratio of the
circumference of the circle to the diameter.
------------------------------------------------------------------------------
PLUSP [Function]
Args: (number)
Returns T if NUMBER > 0; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 60
------------------------------------------------------------------------------
POP [Macro]
Syntax: (pop place)
Pops one item off the front of the list in PLACE and returns it.
------------------------------------------------------------------------------
POSITION [Function]
Args: (item sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
Returns the index of the first element in SEQUENCE that satisfies TEST with
ITEM; NIL if no such element exists.
------------------------------------------------------------------------------
POSITION-IF [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the index of the first element in SEQUENCE that satisfies TEST; NIL
if no such element exists.
------------------------------------------------------------------------------
POSITION-IF-NOT [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence)) (key #'identity))
Returns the index of the first element in SEQUENCE that does not satisfy TEST;
NIL if no such element exists.
------------------------------------------------------------------------------
PPRINT [Function]
Args: (object &optional (stream *standard-output*))
Pretty-prints OBJECT. Returns OBJECT. Equivalent to
(WRITE :STREAM STREAM :PRETTY T)
The SI:PRETTY-PRINT-FORMAT property N (which must be a non-negative integer)
of a symbol SYMBOL controls the pretty-printing of form
(SYMBOL f1 ... fN fN+1 ... fM)
in such a way that the subforms fN+1, ..., fM are regarded as the 'body' of
the entire form. For instance, the property value of 2 is initially given
to the symbol DO.
------------------------------------------------------------------------------
PRIN1 [Function]
Args: (object &optional (stream *standard-output*))
Prints OBJECT in the mostly readable representation. Returns OBJECT.
Equivalent to (WRITE :STREAM STREAM :ESCAPE T).
------------------------------------------------------------------------------
PRIN1-TO-STRING [Function]
Args: (object)
Returns as a string the printed representation of OBJECT in the mostly
readable representation.
Equivalent to (WRITE-TO-STRING :STREAM STREAM :ESCAPE T).
------------------------------------------------------------------------------
PRINC [Function]
Args: (object &optional (stream *standard-output*))
Prints OBJECT without escape characters. Returns OBJECT. Equivalent to
(WRITE :STREAM STREAM :ESCAPE NIL).
------------------------------------------------------------------------------
KCL Dictionary Page 61
------------------------------------------------------------------------------
PRINC-TO-STRING [Function]
Args: (object)
Returns as a string the printed representation of OBJECT without escape
characters. Equivalent to
(WRITE-TO-STRING :STREAM STREAM :ESCAPE NIL).
------------------------------------------------------------------------------
PRINT [Function]
Args: (object &optional (stream *standard-output*))
Outputs a newline character, and then prints OBJECT in the mostly readable
representation. Returns OBJECT. Equivalent to
(PROGN (TERPRI STREAM) (WRITE :STREAM STREAM :ESCAPE T)).
------------------------------------------------------------------------------
*PRINT-ARRAY* [Variable]
Whether the KCL printer should print array elements.
------------------------------------------------------------------------------
*PRINT-BASE* [Variable]
The radix in which the KCL printer prints integers and rationals.
The value must be an integer from 2 to 36, inclusive.
------------------------------------------------------------------------------
*PRINT-CASE* [Variable]
The case in which the KCL printer should print ordinary symbols.
The value must be one of the keywords :UPCASE, :DOWNCASE, and :CAPITALIZE.
------------------------------------------------------------------------------
*PRINT-CIRCLE* [Variable]
Whether the KCL printer should take care of circular lists.
------------------------------------------------------------------------------
*PRINT-ESCAPE* [Variable]
Whether the KCL printer should put escape characters whenever appropriate.
------------------------------------------------------------------------------
*PRINT-GENSYM* [Variable]
Whether the KCL printer should prefix symbols with no home package
with "#:".
------------------------------------------------------------------------------
*PRINT-LENGTH* [Variable]
How many elements the KCL printer should print at each level of nested data
object. Unlimited if NIL.
------------------------------------------------------------------------------
*PRINT-LEVEL* [Variable]
How many levels deep the KCL printer should print. Unlimited if NIL.
------------------------------------------------------------------------------
*PRINT-PRETTY* [Variable]
Whether the KCL printer should pretty-print. See the function doc of PPRINT
for more information about pretty-printing.
------------------------------------------------------------------------------
*PRINT-RADIX* [Variable]
Whether the KCL printer should print the radix indicator when printing
integers and rationals.
------------------------------------------------------------------------------
KCL Dictionary Page 62
------------------------------------------------------------------------------
PROBE-FILE [Function]
Args: (file)
Returns T if the file exists; NIL otherwise.
------------------------------------------------------------------------------
PROCESS [Function]
Args: (progname &optional (ipc-message "")
&key block console debug dir input output username list data ioc)
KCL specific: Creates a process. Only KCL/AOS supports this function.
------------------------------------------------------------------------------
PROCLAIM [Function]
Args: (decl-spec)
Puts the declaration given by DECL-SPEC into effect globally. See the doc of
DECLARE for possible DECL-SPECs.
------------------------------------------------------------------------------
PROCLAMATION [Function]
Args: (decl-spec)
KCL specific: Returns T if the specified declaration is globally in effect;
NIL otherwise. See the doc of DECLARE for possible DECL-SPECs.
------------------------------------------------------------------------------
PROG [Macro]
Syntax: (prog ({var | (var [init])}*) {decl}* {tag | statement}*)
Creates a NIL block, binds VARs in parallel, and then executes STATEMENTs.
------------------------------------------------------------------------------
PROG* [Macro]
Syntax: (prog* ({var | (var [init])}*) {decl}* {tag | statement}*)
Creates a NIL block, binds VARs sequentially, and then executes STATEMENTs.
------------------------------------------------------------------------------
PROG1 [Macro]
Syntax: (prog1 first {form}*)
Evaluates FIRST and FORMs in order, and returns the (single) value of FIRST.
------------------------------------------------------------------------------
PROG2 [Macro]
Syntax: (prog2 first second {forms}*)
Evaluates FIRST, SECOND, and FORMs in order, and returns the (single) value
of SECOND.
------------------------------------------------------------------------------
PROGN [Special form]
Syntax: (progn {form}*)
Evaluates FORMs in order, and returns whatever the last FORM returns.
------------------------------------------------------------------------------
PROGV [Special form]
Syntax: (progv symbols values {form}*)
SYMBOLS must evaluate to a list of variables. VALUES must evaluate to a list
of initial values. Evaluates FORMs as a PROGN, with each variable bound (as
special) to the corresponding value.
------------------------------------------------------------------------------
KCL Dictionary Page 63
------------------------------------------------------------------------------
PROVIDE [Function]
Args: (module-name)
Adds the specified module to the list of modules maintained in *MODULES*.
------------------------------------------------------------------------------
PSETF [Macro]
Syntax: (psetf {place newvalue}*)
Similar to SETF, but evaluates all NEWVALUEs first, and then replaces the
value in each PLACE with the value of the corresponding NEWVALUE. Returns
NIL always.
------------------------------------------------------------------------------
PSETQ [Macro]
Syntax: (psetq {var form}*)
Similar to SETQ, but evaluates all FORMs first, and then assigns each value to
the corresponding VAR. Returns NIL always.
------------------------------------------------------------------------------
PUSH [Macro]
Syntax: (push item place)
Conses ITEM onto the list in PLACE, and returns the new list.
------------------------------------------------------------------------------
PUSHNEW [Macro]
Syntax: (pushnew item place {keyword value}*)
If ITEM is already in the list stored in PLACE, does nothing. Else, conses
ITEM onto the list. Returns NIL. If no KEYWORDs are supplied, each element
in the list is compared with ITEM by EQL, but the comparison can be controlled
by supplying keywords :TEST, :TEST-NOT, and/or :KEY.
------------------------------------------------------------------------------
*QUERY-IO* [Variable]
The query I/O stream.
------------------------------------------------------------------------------
QUOTE [Special form]
Syntax: (quote x) or 'x
Simply returns X without evaluating it.
------------------------------------------------------------------------------
RANDOM [Function]
Args: (number &optional (state *random-state*))
Generates a uniformly distributed pseudo-random number between zero
(inclusive) and NUMBER (exclusive), by using the random state object STATE.
------------------------------------------------------------------------------
RANDOM-STATE [Type]
A random state is used to encapsulate state information used by the
pseudo-random number generator.
A random state is denoted by prefixing a number with '#$'.
------------------------------------------------------------------------------
*RANDOM-STATE* [Variable]
The default random-state object used by RAMDOM.
------------------------------------------------------------------------------
KCL Dictionary Page 64
------------------------------------------------------------------------------
RANDOM-STATE-P [Function]
Args: (x)
Returns T if X is a random-state object; NIL otherwise.
------------------------------------------------------------------------------
RASSOC [Function]
Args: (item alist &key (test #'eql) test-not (key #'identity))
Returns the first cons in ALIST whose cdr is equal to ITEM.
------------------------------------------------------------------------------
RASSOC-IF [Function]
Args: (predicate alist)
Returns the first cons in ALIST whose cdr satisfies PREDICATE.
------------------------------------------------------------------------------
RASSOC-IF-NOT [Function]
Args: (predicate alist)
Returns the first cons in ALIST whose cdr does not satisfy PREDICATE.
------------------------------------------------------------------------------
RATIO [Type]
A ratio represents a mathematical ratio of two integers. A ratio is
denoted by its numerator and denominator, separated by a slash '/'. More
precisely, the following syntax is normally used.
{ [sign]{digit-in-default-radix}+ / {digit-in-default-radix}+
| {#b | #B} [sign] {radix-2-digit}+ / {radix-2-digit}+
| {#o | #O} [sign] {radix-8-digit}+ / {radix-8-digit}+
| {#x | #X} [sign] {radix-16-digit}+ / {radix-16-digit}+
| {#2r | #2R} [sign] {radix-2-digit}+ / {radix-2-digit}+
....
| {#36r | #36R} [sign] {radix-36-digit}+ / {radix-36-digit}+ }
See the type doc of INTEGER for the syntactic variables used here.
------------------------------------------------------------------------------
RATIONAL [Function]
Args: (number)
Converts NUMBER into rational accurately and returns it.
------------------------------------------------------------------------------
RATIONALIZE [Function]
Args: (number)
Converts NUMBER into rational approximately and returns it.
------------------------------------------------------------------------------
RATIONALP [Function]
Args: (x)
Returns T if X is an integer or a ratio; NIL otherwise.
------------------------------------------------------------------------------
READ [Function]
Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil)
(recursivep nil))
Reads in the next object from STREAM.
------------------------------------------------------------------------------
*READ-BASE* [Variable]
The radix that the KCL reader reads numbers in.
------------------------------------------------------------------------------
KCL Dictionary Page 65
------------------------------------------------------------------------------
READ-BYTE [Function]
Args: (stream &optional (eof-error-p t) (eof-value nil))
Reads the next byte from STREAM.
------------------------------------------------------------------------------
READ-CHAR [Function]
Args: (&optional (stream *standard-input*) (eof-error-p t)
(eof-value nil) (recursive-p nil))
Reads a character from STREAM.
------------------------------------------------------------------------------
READ-CHAR-NO-HANG [Function]
Args: (&optional (stream *standard-input*) (eof-error-p t)
(eof-value nil) (recursive-p nil))
Returns the next character from STREAM if one is available; NIL otherwise.
------------------------------------------------------------------------------
*READ-DEFAULT-FLOAT-FORMAT* [Variable]
The floating-point format the KCL reader uses when reading floating-point
numbers that have no exponent marker or have e or E for an exponent marker.
Must be one of SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT, and LONG-FLOAT.
------------------------------------------------------------------------------
READ-DELIMITED-LIST [Function]
Args: (char &optional (stream *standard-input*) (recursive-p nil))
Reads objects from STREAM until the next character after an object's
representation is CHAR. Returns a list of the objects read.
------------------------------------------------------------------------------
READ-FROM-STRING [Function]
Args: (string &optional (eof-error-p t) (eof-value nil)
&key (start 0) (end (length string)) (preserve-whitespace nil))
Reads an object from STRING.
------------------------------------------------------------------------------
READ-LINE [Function]
Args: (&optional (stream *standard-input*) (eof-error-p t)
(eof-value nil) (recursive-p nil))
Returns a line of text read from STREAM as a string, discarding the newline
character.
------------------------------------------------------------------------------
READ-PRESERVING-WHITESPACE [Function]
Args: (&optional (stream *standard-input*) (eof-error-p t) (eof-value nil)
(recursive-p nil))
Reads an object from STREAM, preserving the whitespace that followed the
object.
------------------------------------------------------------------------------
*READ-SUPPRESS* [Variable]
When the value of this variable is NIL, the KCL reader operates normally.
When it is non-NIL, then the reader parses input characters but much of what
is read is not interpreted.
------------------------------------------------------------------------------
KCL Dictionary Page 66
------------------------------------------------------------------------------
READTABLE [Type]
A readtable is a data structure that maps characters into syntax types for the
KCL parser.
A readtable is denoted as #<a readtable>.
------------------------------------------------------------------------------
*READTABLE* [Variable]
The current readtable.
------------------------------------------------------------------------------
READTABLEP [Function]
Args: (x)
Returns T if X is a readtable object; NIL otherwise.
------------------------------------------------------------------------------
REALPART [Function]
Args: (number)
Extracts the real part of NUMBER.
------------------------------------------------------------------------------
REDUCE [Function]
Args: (function sequence
&key (from-end nil) (start 0) (end (length sequence)) initial-value)
Combines all the elements of SEQUENCE using a binary operation FUNCTION.
If INITIAL-VALUE is supplied, it is logically placed before the SEQUENCE.
------------------------------------------------------------------------------
REM [Function]
Args: (number divisor)
Returns the second value of (TRUNCATE NUMBER DIVISOR).
------------------------------------------------------------------------------
REMF [Macro]
Syntax: (remf place indicator)
PLACE may be any place expression acceptable to SETF, and is expected
to hold a property list or NIL. This list is destructively altered to
remove the property specified by INDICATOR. Returns T if such a
property was present; NIL otherwise.
------------------------------------------------------------------------------
REMHASH [Function]
Args: (key hash-table)
Removes any entry for KEY in HASH-TABLE. Returns T if such an entry
existed; NIL otherwise.
------------------------------------------------------------------------------
REMOVE [Function]
Args: (item sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (count most-positive-fixnum)
(key #'identity))
Returns a copy of SEQUENCE with ITEM removed.
------------------------------------------------------------------------------
KCL Dictionary Page 67
------------------------------------------------------------------------------
REMOVE-DUPLICATES [Function]
Args: (sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (key #'identity))
The elements of SEQUENCE are examined, and if any two match, one is discarded.
Returns the resulting sequence.
------------------------------------------------------------------------------
REMOVE-IF [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a copy of SEQUENCE with elements satisfying TEST removed.
------------------------------------------------------------------------------
REMOVE-IF-NOT [Function]
Args: (test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a copy of SEQUENCE with elements not satisfying TEST removed.
------------------------------------------------------------------------------
REMPROP [Function]
Args: (symbol indicator)
Look on property list of SYMBOL for property with specified
INDICATOR. If found, splice this indicator and its value out of
the plist, and return the tail of the original list starting with
INDICATOR. If not found, returns NIL with no side effects.
------------------------------------------------------------------------------
RENAME-FILE [Function]
Args: (file new-name)
Renames the file FILE to NEW-NAME. FILE may be a string, a pathname, or
a stream.
------------------------------------------------------------------------------
RENAME-PACKAGE [Function]
Args: (package new-name &optional (new-nicknames nil))
Replaces the old name and nicknames of PACKAGE with NEW-NAME and
NEW-NICKNAMES.
------------------------------------------------------------------------------
REPLACE [Function]
Args: (sequence1 sequence2
&key (start1 0) (end1 (length sequence1))
(start2 0) (end2 (length sequence2)))
Destructively modifies SEQUENCE1 by copying successive elements into it from
SEQUENCE2.
------------------------------------------------------------------------------
REQUIRE [Function]
Args: (module-name &optional (pathname))
If the specified module is not present, then loads the appropriate file(s).
PATHNAME may be a single pathname or it may be a list of pathnames.
------------------------------------------------------------------------------
KCL Dictionary Page 68
------------------------------------------------------------------------------
REST [Function]
Args: (x)
Equivalent to (CDR X).
------------------------------------------------------------------------------
RETURN [Macro]
Syntax: (return [result])
Returns from the lexically surrounding NIL block. The value of RESULT,
which defaults to NIL, is returned as the value of the block.
------------------------------------------------------------------------------
RETURN-FROM [Special form]
Syntax: (return-from name [result])
Returns from the lexically surrounding block whose name is NAME. The value
of RESULT, which defaults to NIL, is returned as the value of the block.
------------------------------------------------------------------------------
REVAPPEND [Function]
Args: (x y)
Equivalent to (APPEND (REVERSE X) Y)
------------------------------------------------------------------------------
REVERSE [Function]
Args: (sequence)
Returns a new sequence containing the same elements as SEQUENCE but in
reverse order.
------------------------------------------------------------------------------
ROOM [Function]
Args: (&optional (x t))
Displays information about storage allocation in the following format.
* for each type class
* the number of pages so-far allocated for the type class
* the maximum number of pages for the type class
* the percentage of used cells to cells so-far allocated
* the number of times the garbage collector has been called to
collect cells of the type class
* the implementation types that belongs to the type class
* the number of pages actually allocated for contiguous blocks
* the maximum number of pages for contiguous blocks
* the number of times the garbage collector has been called to collect
contiguous blocks
* the number of pages in the hole
* the maximum number of pages for relocatable blocks
* the number of times the garbage collector has been called to collect
relocatable blocks
* the total number of pages allocated for cells
* the total number of pages allocated
* the number of available pages
* the number of pages KCL can use.
The number of times the garbage collector has been called is not shown,
if the number is zero. The optional X is ignored.
------------------------------------------------------------------------------
KCL Dictionary Page 69
------------------------------------------------------------------------------
ROTATEF [Macro]
Syntax: (rotatef {place}*)
Evaluates PLACEs in turn, then assigns to each PLACE the value of the form to
its right. The rightmost PLACE gets the value of the leftmost PLACE.
Returns NIL always.
------------------------------------------------------------------------------
ROUND [Function]
Args: (number &optional (divisor 1))
Rounds NUMBER/DIVISOR to nearest integer. The second returned value is the
remainder.
------------------------------------------------------------------------------
RPLACA [Function]
Args: (x y)
Replaces the car of X with Y, and returns the modified X.
------------------------------------------------------------------------------
RPLACD [Function]
Args: (x y)
Replaces the cdr of X with Y, and returns the modified X.
------------------------------------------------------------------------------
SAVE [Function]
Args: (pathname)
KCL specific: Saves the current KCL core image into a program file specified
by PATHNAME. This function depends on the version of KCL. See KCL Report for
the details.
------------------------------------------------------------------------------
SBIT [Function]
Args: (simple-bit-array &rest subscripts)
Returns the bit from SIMPLE-BIT-ARRAY at SUBSCRIPTS.
------------------------------------------------------------------------------
SCALE-FLOAT [Function]
Args: (float integer)
Returns (* FLOAT (expt (float-radix FLOAT) INTEGER)).
------------------------------------------------------------------------------
SCHAR [Function]
Args: (simple-string index)
Returns the character object representing the INDEX-th character in STRING.
This is faster than CHAR.
------------------------------------------------------------------------------
SEARCH [Function]
Args: (sequence1 sequence2
&key (from-end nil) (test #'eql) test-not (start1 0) (start2 0)
(end1 (length sequence1)) (end2 (length sequence2))
(key #'identity))
A search is conducted for the first subsequence of SEQUENCE2 which
element-wise matches SEQUENCE1. If there is such a subsequence in SEQUENCE2,
the index of the its leftmost element is returned; otherwise, NIL is
returned.
------------------------------------------------------------------------------
KCL Dictionary Page 70
------------------------------------------------------------------------------
SECOND [Function]
Args: (x)
Equivalent to (CADR X).
------------------------------------------------------------------------------
SEQUENCE [Type]
A sequence is either a list or a vector.
------------------------------------------------------------------------------
SET [Function]
Args: (symbol value)
Assigns the value of VALUE to the dynamic variable named by SYMBOL, and
returns the value assigned.
------------------------------------------------------------------------------
SET-CHAR-BIT [Function]
Args: (char name newvalue)
Returns a character just like CHAR except that the named bit is set or
cleared, according to whether NEWVALUE is non-NIL or NIL. This function
is useless in KCL.
------------------------------------------------------------------------------
SET-DIFFERENCE [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list of elements of LIST1 that do not appear in LIST2.
------------------------------------------------------------------------------
SET-DISPATCH-MACRO-CHARACTER [Function]
Args: (disp-char sub-char function &optional (readtable *readtable*))
Causes FUNCTION to be called when the DISP-CHAR followed by SUB-CHAR is
read.
------------------------------------------------------------------------------
SET-EXCLUSIVE-OR [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns a list of elements appearing exactly once in LIST1 and LIST2.
------------------------------------------------------------------------------
SET-MACRO-CHARACTER [Function]
Args: (char function
&optional (non-terminating-p nil) (readtable *readtable*))
Causes CHAR to be a macro character that, when seen by READ, causes FUNCTION
to be called.
------------------------------------------------------------------------------
SET-SYNTAX-FROM-CHAR [Function]
Args: (to-char from-char
&optional (to-readtable *readtable*) (from-readtable nil))
Makes the syntax of TO-CHAR in TO-READTABLE be the same as the syntax of
FROM-CHAR in FROM-READTABLE.
------------------------------------------------------------------------------
KCL Dictionary Page 71
------------------------------------------------------------------------------
SETF [Macro]
Syntax: (setf {place newvalue}*)
Replaces the value in PLACE with the value of NEWVALUE, from left to right.
Returns the value of the last NEWVALUE. Each PLACE may be any one of the
following:
* A symbol that names a variable.
* A function call form whose first element is the name of the following
functions:
nth elt subseq rest first ... tenth
c?r c??r c???r c????r
aref svref char schar bit sbit fill-poiter
get getf documentation symbol-value symbol-function
symbol-plist macro-function gethash
char-bit ldb mask-field
apply
where '?' stands for either 'a' or 'd'.
* the form (THE type place) with PLACE being a place recognized by SETF.
* a macro call which expands to a place recognized by SETF.
* any form for which a DEFSETF or DEFINE-SETF-METHOD declaration has been
made.
------------------------------------------------------------------------------
SETQ [Special form]
Syntax: (setq {var form}*)
VARs are not evaluated and must be symbols. Assigns the value of the first
FORM to the first VAR, then assigns the value of the second FORM to the second
VAR, and so on. Returns the last value assigned.
------------------------------------------------------------------------------
SEVENTH [Function]
Args: (x)
Equivalent to (CADDR (CDDDDR X)).
------------------------------------------------------------------------------
SHADOW [Function]
Args: (symbols &optional (package *package*))
Creates an internal symbol in PACKAGE with the same name as each of the
specified SYMBOLS. SYMBOLS must be a list of symbols or a symbol.
------------------------------------------------------------------------------
SHADOWING-IMPORT [Function]
Args: (symbols &optional (package *package*))
Imports SYMBOLS into PACKAGE, disregarding any name conflict. If a symbol
of the same name is already present, then it is uninterned. SYMBOLS must
be a list of symbols or a symbol.
------------------------------------------------------------------------------
SHIFTF [Macro]
Syntax: (shiftf {place}+ newvalue)
Evaluates all PLACEs and NEWVALUE in turn, then assigns the value of each
form to the PLACE on its left. Returns the original value of the leftmost
form.
------------------------------------------------------------------------------
SHORT-FLOAT-EPSILON [Constant]
The smallest positive short-float that satisfies
(not (= (float 1 e) (+ (float 1 e) e))).
------------------------------------------------------------------------------
KCL Dictionary Page 72
------------------------------------------------------------------------------
SHORT-FLOAT-NEGATIVE-EPSILON [Constant]
The smallest positive short-float that satisfies
(not (= (float 1 e) (- (float 1 e) e))).
------------------------------------------------------------------------------
SHORT-SITE-NAME [Function]
Args: ()
Returns a string that identifies the physical location of the current KCL.
------------------------------------------------------------------------------
SIGNUM [Function]
Args: (number)
If NUMBER is zero, returns NUMBER; else returns (/ NUMBER (ABS NUMBER)).
------------------------------------------------------------------------------
SIMPLE-ARRAY [Type]
A simple-array is an array that is not displaced to another array, has no
fill pointer, and is not to have its size adjusted.
------------------------------------------------------------------------------
SIMPLE-BIT-VECTOR [Type]
A simple-bit-vector is a bit-vector that is not displaced to another
bit-vector, has no fill pointer, and is not to have its size adjusted.
------------------------------------------------------------------------------
SIMPLE-BIT-VECTOR-P [Function]
Args: (x)
Returns T if X is a simple bit-vector; NIL otherwise.
------------------------------------------------------------------------------
SIMPLE-STRING [Type]
A simple-string is a string that is not displaced to another string, has no
fill pointer, and is not to have its size adjusted.
------------------------------------------------------------------------------
SIMPLE-STRING-P [Function]
Args: (x)
Returns T if X is a simple string; NIL otherwise.
------------------------------------------------------------------------------
SIMPLE-VECTOR [Type]
A simple-vector is a vector that is not displaced to another vector, has no
fill pointer, and is not to have its size adjusted.
------------------------------------------------------------------------------
SIMPLE-VECTOR-P [Function]
Args: (x)
Returns T if X is a simple vector; NIL otherwise.
------------------------------------------------------------------------------
SIN [Function]
Args: (radians)
Returns the sine of RADIANS.
------------------------------------------------------------------------------
SINGLE-FLOAT-EPSILON [Constant]
Same as LONG-FLOAT-EPSILON.
------------------------------------------------------------------------------
KCL Dictionary Page 73
------------------------------------------------------------------------------
SINGLE-FLOAT-NEGATIVE-EPSILON [Constant]
Same as LONG-FLOAT-NEGATIVE-EPSILON.
------------------------------------------------------------------------------
SINH [Function]
Args: (number)
Returns the hyperbolic sine of NUMBER.
------------------------------------------------------------------------------
SIXTH [Function]
Args: (x)
Equivalent to (CADR (CDDDDR X)).
------------------------------------------------------------------------------
SLEEP [Function]
Args: (n)
This function causes execution to be suspended for N seconds. N may
be any non-negative, non-complex number.
------------------------------------------------------------------------------
SOFTWARE-TYPE [Function]
Args: ()
Returns a string that identifies the software type of the software
under which KCL is currently running.
------------------------------------------------------------------------------
SOFTWARE-VERSION [Function]
Args: ()
Returns a string that identifies the software version of the software
under which KCL is currently running.
------------------------------------------------------------------------------
SOME [Function]
Args: (predicate sequence &rest more-sequences)
PREDICATE is applied to the 0-th elements of SEQUENCEs, then possibly to
1-st elements, and so on. Returns the first non-NIL value encountered, or
NIL if the end of a sequence is reached.
------------------------------------------------------------------------------
SORT [Function]
Args: (sequence predicate &key (key #'identity))
Destructively sorts SEQUENCE. PREDICATE should return non-NIL if its first
argument is to precede its second argument.
------------------------------------------------------------------------------
KCL Dictionary Page 74
------------------------------------------------------------------------------
SPECIAL-FORM-P [Function]
Args: (symbol)
Returns T if SYMBOL globally names a special form; NIL otherwise.
The special forms defined in Steele's manual are:
block if progv
catch labels quote
compiler-let let return-from
declare let* setq
eval-when macrolet tagbody
flet multiple-value-call the
function multiple-value-prog1 throw
go progn unwind-protect
In addition, KCL implements the following macros as special forms, though
of course macro-expanding functions such as MACROEXPAND work correctly for
these macros.
and incf prog1
case locally prog2
cond loop psetq
decf multiple-value-bind push
defmacro multiple-value-list return
defun multiple-value-set setf
do or unless
do* pop when
dolist prog
dotimes prog*
------------------------------------------------------------------------------
SQRT [Function]
Args: (number)
Returns the principal square root of NUMBER.
------------------------------------------------------------------------------
STABLE-SORT [Function]
Args: (sequence predicate &key (key #'identity))
Destructively sorts SEQUENCE. PREDICATE should return non-NIL if its first
argument is to precede its second argument.
------------------------------------------------------------------------------
STANDARD-CHAR [Type]
A standard-char is a space character (#\Space), a newline character
(#\Newline,) or a character that represents one of the following letters.
! " # $ % & ' ( ) * + , - . / 0 1 2 3 4
5 6 7 8 9 : ; < = > ? @ A B C D E F G H
I J K L M N O P Q R S T U V W X Y Z [ \
] ^ _ ` a b c d e f g h i j k l m n o p
q r s t u v w x y z { | } ~
------------------------------------------------------------------------------
STANDARD-CHAR-P [Function]
Args: (char)
Returns T if CHAR is a standard character, i.e., one of the 95 ASCII printing
characters #\Space to #\~ and #Newline; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 75
------------------------------------------------------------------------------
*STANDARD-INPUT* [Variable]
The default input stream used by the KCL reader.
------------------------------------------------------------------------------
*STANDARD-OUTPUT* [Variable]
The default output stream used by the KCL printer.
------------------------------------------------------------------------------
STEP [Macro]
Syntax: (step form)
Evaluates FORM in the single-step mode and returns the value.
------------------------------------------------------------------------------
STREAM [Type]
A stream is a source or sink of data, typically characters or bytes.
A stream is denoted in one of the following ways:
#<input stream ??> ?? being a file name
#<output stream ??> ?? being a file name
#<string-input stream from ??> ?? being a string
#<a string-output stream>
#<a two-way stream>
#<an echo stream>
#<synonym stream to ??> ?? being a symbol
#<a concatenated stream>
#<a broadcast stream>
------------------------------------------------------------------------------
STREAM-ELEMENT-TYPE [Function]
Args: (stream)
Returns a type specifier for the kind of object returned by STREAM.
------------------------------------------------------------------------------
STREAMP [Function]
Args: (x)
Returns T if X is a stream object; NIL otherwise.
------------------------------------------------------------------------------
STRING [Type]
A string is a vector of characters. A string is denoted by surrounding
the characters with double quotes '"'.
Some strings may be displaced to another string, may have a fill pointer,
or may be adjusted its size. Other strings are called simple strings.
------------------------------------------------------------------------------
STRING [Function]
Args: (x)
Coerces X into a string. If X is a string, then returns X itself. If X is a
symbol, then returns X's print name. If X is a character, then returns a one
element string containing that character. Signals an error if X cannot be
coerced into a string.
------------------------------------------------------------------------------
STRING-CAPITALIZE [Function]
Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with the first character of each word converted to
upper-case, and remaining characters in the word converted to lower case.
------------------------------------------------------------------------------
KCL Dictionary Page 76
------------------------------------------------------------------------------
STRING-CHAR [Type]
A string-char is a character whose bits and font attributes are zero.
Any KCL character is a string-character.
------------------------------------------------------------------------------
STRING-CHAR-P [Function]
Args: (char)
Returns T if CHAR can be stored in a string. In KCL, this function always
returns T since any character in KCL can be stored in a string.
------------------------------------------------------------------------------
STRING-DOWNCASE [Function]
Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all upper case characters converted to
lowercase.
------------------------------------------------------------------------------
STRING-EQUAL [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Given two strings (string1 and string2), and optional integers start1,
start2, end1 and end2, compares characters in string1 to characters in
string2 (using char-equal).
------------------------------------------------------------------------------
STRING-GREATERP [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING>, but ignores cases.
------------------------------------------------------------------------------
STRING-LEFT-TRIM [Function]
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
left end.
------------------------------------------------------------------------------
STRING-LESSP [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING<, but ignores cases.
------------------------------------------------------------------------------
STRING-NOT-EQUAL [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING=, but ignores cases.
------------------------------------------------------------------------------
STRING-NOT-GREATERP [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING<=, but ignores cases.
------------------------------------------------------------------------------
KCL Dictionary Page 77
------------------------------------------------------------------------------
STRING-NOT-LESSP [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Similar to STRING>=, but ignores cases.
------------------------------------------------------------------------------
STRING-RIGHT-TRIM [Function]
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from the
right end.
------------------------------------------------------------------------------
STRING-TRIM [Function]
Args: (char-bag string)
Returns a copy of STRING with the characters in CHAR-BAG removed from both
ends.
------------------------------------------------------------------------------
STRING-UPCASE [Function]
Args: (string &key (start 0) (end (length string)))
Returns a copy of STRING with all lower case characters converted to
uppercase.
------------------------------------------------------------------------------
STRING/= [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Returns NIL if STRING1 and STRING2 are character-wise CHAR=. Otherwise,
returns the index to the longest common prefix of the strings.
------------------------------------------------------------------------------
STRING< [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
If STRING1 is lexicographically less than STRING2, then returns the longest
common prefix of the strings. Otherwise, returns NIL.
------------------------------------------------------------------------------
STRING<= [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
If STRING1 is lexicographically less than or equal to STRING2, then returns
the longest common prefix of the two strings. Otherwise, returns NIL.
------------------------------------------------------------------------------
STRING= [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
Returns T if the two strings are character-wise CHAR=; NIL otherwise.
------------------------------------------------------------------------------
KCL Dictionary Page 78
------------------------------------------------------------------------------
STRING> [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
If STRING1 is lexicographically greater than STRING2, then returns the
longest common prefix of the strings. Otherwise, returns NIL.
------------------------------------------------------------------------------
STRING>= [Function]
Args: (string1 string2
&key (start1 0) (end1 (length string1))
(start2 0) (end2 (length string2)))
If STRING1 is lexicographically greater than or equal to STRING2, then returns
the longest common prefix of the strings. Otherwise, returns NIL.
------------------------------------------------------------------------------
STRINGP [Function]
Args: (x)
Returns T if X is a string; NIL otherwise.
------------------------------------------------------------------------------
STRUCTURE [Type]
Structures are instances of user-defined data types that have a fixed number
of named components. In the simplest case, a structure is denoted as
#s(structure-name slot-value1 ... slot-valuen)
------------------------------------------------------------------------------
SUBLIS [Function]
Args: (alist tree &key (test #'eql) test-not (key #'identity))
Substitutes from ALIST for subtrees of TREE nondestructively.
------------------------------------------------------------------------------
SUBSEQ [Function]
Args: (sequence start &optional (end (length sequence)))
Returns a copy of a subsequence of SEQUENCE between START (inclusive) and
END (exclusive).
------------------------------------------------------------------------------
SUBSETP [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns T if every element of LIST1 appears in LIST2; NIL otherwise.
------------------------------------------------------------------------------
SUBST [Function]
Args: (new old tree &key (test #'eql) test-not (key #'identity))
Substitutes NEW for subtrees of TREE that match OLD.
------------------------------------------------------------------------------
SUBST-IF [Function]
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that satisfy TEST.
------------------------------------------------------------------------------
SUBST-IF-NOT [Function]
Args: (new test tree &key (key #'identity))
Substitutes NEW for subtrees of TREE that do not satisfy TEST.
------------------------------------------------------------------------------
KCL Dictionary Page 79
------------------------------------------------------------------------------
SUBSTITUTE [Function]
Args: (newitem olditem sequence
&key (from-end nil) (test #'eql) test-not (start 0)
(end (length sequence)) (count most-positive-fixnum)
(key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that OLDITEMs are replaced with NEWITEM.
------------------------------------------------------------------------------
SUBSTITUTE-IF [Function]
Args: (newitem test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that all elements satisfying TEST are replaced with NEWITEM.
------------------------------------------------------------------------------
SUBSTITUTE-IF-NOT [Function]
Args: (new test sequence
&key (from-end nil) (start 0) (end (length sequence))
(count most-positive-fixnum) (key #'identity))
Returns a sequence of the same kind as SEQUENCE with the same elements
except that all elements not satisfying TEST are replaced with NEWITEM.
------------------------------------------------------------------------------
SUBTYPEP [Function]
Args: (type1 type2)
Returns T if TYPE1 is a subtype of TYPE2; NIL otherwise. If it could not
determine, then returns NIL as the second value. Otherwise, the second value
is T.
------------------------------------------------------------------------------
SVREF [Function]
Args: (simple-vector index)
Returns the INDEX-th element of SIMPLE-VECTOR.
------------------------------------------------------------------------------
SXHASH [Function]
Args: (object)
Computes a hash code for OBJECT and returns it as an integer.
------------------------------------------------------------------------------
SYMBOL-FUNCTION [Function]
Args: (symbol)
Returns the current global function definition named by SYMBOL.
------------------------------------------------------------------------------
SYMBOL-NAME [Function]
Args: (symbol)
Returns the print name of the symbol SYMBOL.
------------------------------------------------------------------------------
SYMBOL-PACKAGE [Function]
Args: (symbol)
Returns the contents of the package cell of the symbol SYMBOL.
------------------------------------------------------------------------------
KCL Dictionary Page 80
------------------------------------------------------------------------------
SYMBOL-PLIST [Function]
Args: (symbol)
Returns the property list of SYMBOL.
------------------------------------------------------------------------------
SYMBOL-VALUE [Function]
Args: (symbol)
Returns the current value of the dynamic (special) variable named by SYMBOL.
------------------------------------------------------------------------------
SYMBOLP [Function]
Args: (x)
Returns T if X is a symbol; NIL otherwise.
------------------------------------------------------------------------------
SYSTEM [Function]
Args: (string)
KCL specific: Executes a Shell command as if STRING is an input to the Shell.
Not all versions of KCL support this function.
------------------------------------------------------------------------------
T [Type]
The type T is a supertype of every type.
------------------------------------------------------------------------------
T [Constant]
Holds T.
------------------------------------------------------------------------------
TAGBODY [Special form]
Syntax: (tagbody {tag | statement}*)
Executes STATEMENTs and returns NIL if it falls off the end.
------------------------------------------------------------------------------
TAILP [Function]
Args: (sublist list)
Returns T if SUBLIST is one of the conses in LIST; NIL otherwise.
------------------------------------------------------------------------------
TAN [Function]
Args: (radians)
Returns the tangent of RADIANS.
------------------------------------------------------------------------------
TANH [Function]
Args: (number)
Returns the hyperbolic tangent of NUMBER.
------------------------------------------------------------------------------
TENTH [Function]
Args: (x)
Equivalent to (CADR (CDDDDR (CDDDDR X))).
------------------------------------------------------------------------------
*TERMINAL-IO* [Variable]
The terminal I/O stream.
------------------------------------------------------------------------------
KCL Dictionary Page 81
------------------------------------------------------------------------------
TERMINATION-MESSAGE [Function]
Args: ()
KCL specific: Returns the termination message of the son as a string.
Only KCL/AOS supports this function.
------------------------------------------------------------------------------
TERPRI [Function]
Args: (&optional (stream *standard-output*))
Outputs a newline character.
------------------------------------------------------------------------------
THE [Special form]
Syntax: (the value-type form)
Declares that the value of FORM must be of VALUE-TYPE. Signals an error if
this is not the case.
------------------------------------------------------------------------------
THIRD [Function]
Args: (x)
Equivalent to (CADDR X).
------------------------------------------------------------------------------
THROW [Special form]
Syntax: (throw tag result)
Evaluates TAG and aborts the execution of the most recent CATCH form that sets
up a catcher with the same tag value. The CATCH form returns whatever RESULT
returned.
------------------------------------------------------------------------------
TIME [Macro]
Syntax: (time form)
Evaluates FORM and outputs timing statistics on *TRACE-OUTPUT*.
------------------------------------------------------------------------------
TRACE [Macro]
Syntax: (trace {function-name}*)
Traces the specified functions. With no FUNCTION-NAMEs, returns a list of
functions currently being traced.
------------------------------------------------------------------------------
*TRACE-OUTPUT* [Variable]
The trace output stream.
------------------------------------------------------------------------------
TREE-EQUAL [Function]
Args: (x y &key (test #'eql) test-not)
Returns T if X and Y are isomorphic trees with identical leaves.
------------------------------------------------------------------------------
TRUENAME [Function]
Args: (pathname)
Returns the pathname for the actual file described by PATHNAME.
------------------------------------------------------------------------------
TRUNCATE [Function]
Args: (number &optional (divisor 1))
Returns NUMBER/DIVISOR as an integer, rounded toward 0. The second returned
value is the remainder.
------------------------------------------------------------------------------
KCL Dictionary Page 82
------------------------------------------------------------------------------
TYPE-OF [Function]
Args: (x)
Returns the type of X.
------------------------------------------------------------------------------
TYPECASE [Macro]
Syntax: (typecase keyform {(type {form}*)}*)
Evaluates KEYFORM and tries to find the TYPE in which the value of KEYFORM
belongs. If one is found, then evaluates FORMs that follow the KEY and
returns the value of the last FORM. If not, simply returns NIL.
------------------------------------------------------------------------------
TYPEP [Function]
Args: (x type)
Returns T if X is of the type TYPE; NIL otherwise.
------------------------------------------------------------------------------
UNEXPORT [Function]
Args: (symbols &optional (package *package*))
Makes SYMBOLS no longer accessible as external symbols in PACKAGE. SYMBOLS
must be a list of symbols or a symbol.
------------------------------------------------------------------------------
UNINTERN [Function]
Args: (symbol &optional (package *package*))
Makes SYMBOL no longer present in PACKAGE. Returns T if SYMBOL was present;
NIL otherwise. If PACKAGE is the home package of SYMBOL, then makes SYMBOL
uninterned.
------------------------------------------------------------------------------
UNION [Function]
Args: (list1 list2 &key (test #'eql) test-not (key #'identity))
Returns the union of LIST1 and LIST2.
------------------------------------------------------------------------------
UNLESS [Macro]
Syntax: (unless test {form}*)
If TEST evaluates to NIL, then evaluates FORMs as a PROGN. If not,
simply returns NIL.
------------------------------------------------------------------------------
UNREAD-CHAR [Function]
Args: (character &optional (stream *standard-input*))
Puts CHARACTER back on the front of the input stream STREAM.
------------------------------------------------------------------------------
UNTRACE [Macro]
Syntax: (untrace {function-name}*)
Removes tracing from the specified functions. With no FUNCTION-NAMEs,
untraces all functions.
------------------------------------------------------------------------------
UNUSE-PACKAGE [Function]
Args: (packages-to-unuse &optional (package *package*))
Removes PACKAGES-TO-UNUSE from the use list for PACKAGE.
------------------------------------------------------------------------------
KCL Dictionary Page 83
------------------------------------------------------------------------------
UNWIND-PROTECT [Special form]
Syntax: (unwind-protect protected-form {cleanup-form}*)
Evaluates PROTECTED-FORM and returns whatever it returned. Guarantees that
CLEANUP-FORMs be always evaluated before exiting from the UNWIND-PROTECT
form.
------------------------------------------------------------------------------
UPPER-CASE-P [Function]
Args: (char)
Returns T if CHAR is an upper-case character; NIL otherwise.
------------------------------------------------------------------------------
USE-PACKAGE [Function]
Args: (packages-to-use &optional (package *package*))
Adds all packages in PACKAGE-TO-USE list to the use list for PACKAGE so that
the external symbols of the used packages are available as internal symbols
in PACKAGE.
------------------------------------------------------------------------------
USER-HOMEDIR-PATHNAME [Function]
Args: (&optional host)
Returns the home directory of the logged in user as a pathname. HOST
is ignored.
------------------------------------------------------------------------------
VALUES [Function]
Args: (&rest args)
Returns ARGs in order, as values.
------------------------------------------------------------------------------
VALUES-LIST [Function]
Args: (list)
Returns all of the elements of LIST in order, as values.
------------------------------------------------------------------------------
VECTOR [Type]
A vector is a one-dimensional array. Strings and bit-vectors are kinds of
vectors. Other vectors are called general vectors and are denoted as
#(elem0 ... elemn)
where n is the length of the vector minus one.
Some vectors may be displaced to another vector, may have a fill pointer,
or may be adjusted its size. Other vectors are called simple vectors.
------------------------------------------------------------------------------
VECTOR [Function]
Args: (&rest objects)
Constructs a Simple-Vector from the given objects.
------------------------------------------------------------------------------
VECTOR-POP [Function]
Args: (vector)
Attempts to decrease the fill-pointer of VECTOR by 1 and returns the element
pointed to by the new fill pointer. Signals an error if the old value of
the fill pointer is 0.
------------------------------------------------------------------------------
KCL Dictionary Page 84
------------------------------------------------------------------------------
VECTOR-PUSH [Function]
Args: (new-element vector)
Attempts to set the element of ARRAY designated by its fill pointer to
NEW-ELEMENT and increments the fill pointer by one. Returns NIL if the fill
pointer is too large. Otherwise, returns the new fill pointer value.
------------------------------------------------------------------------------
VECTOR-PUSH-EXTEND [Function]
Args: (new-element vector &optional (extension (length vector)))
Similar to VECTOR-PUSH except that, if the fill pointer gets too large,
extends VECTOR rather then simply returns NIL.
------------------------------------------------------------------------------
VECTORP [Function]
Args: (x)
Returns T if X is a vector; NIL otherwise.
------------------------------------------------------------------------------
WARN [Function]
Args: (format-string &rest args)
Formats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message.
------------------------------------------------------------------------------
WHEN [Macro]
Syntax: (when test {form}*)
If TEST evaluates to non-NIL, then evaluates FORMs as a PROGN. If not,
simply returns NIL.
------------------------------------------------------------------------------
WITH-INPUT-FROM-STRING [Macro]
Syntax: (with-input-from-string (var string {keyword value}*) {decl}* {form}*)
Binds VAR to an input stream that returns characters from STRING and evaluates
the FORMs. The stream is automatically closed on exit. Allowed keywords are
:INDEX, :START, and :END.
------------------------------------------------------------------------------
WITH-OPEN-FILE [Macro]
Syntax: (with-open-file (stream filename {options}*) {decl}* {form}*)
Opens the file whose name is FILENAME, using OPTIONs, and binds the variable
STREAM to a stream to/from the file. Then evaluates FORMs as a PROGN.
The file is automatically closed on exit.
------------------------------------------------------------------------------
WITH-OPEN-STREAM [Macro]
Syntax: (with-open-stream (var stream) {decl}* {form}*)
Evaluates FORMs as a PROGN with VAR bound to the value of STREAM. The stream
is automatically closed on exit.
------------------------------------------------------------------------------
WITH-OUTPUT-TO-STRING [Macro]
Syntax: (with-output-to-string (var [string]) {decl}* {form}*)
Binds VAR to a string output stream that puts characters into STRING, which
defaults to a new string. The stream is automatically closed on exit and
the string is returned.
------------------------------------------------------------------------------
KCL Dictionary Page 85
------------------------------------------------------------------------------
WRITE [Function]
Args: (object &key (stream *standard-output*) (escape *print-escape*)
(radix *print-radix*) (base *print-base*)
(circle *print-circle*) (pretty *print-pretty*)
(level *print-level*) (length *print-length*)
(case *print-case*) (array *print-array*)
(gensym *print-gensym*))
Prints OBJECT in the specified mode. See the variable docs of *PRINT-...*
for the mode.
------------------------------------------------------------------------------
WRITE-BYTE [Function]
Args: (integer stream)
Outputs INTEGER to the binary stream STREAM. Returns INTEGER.
------------------------------------------------------------------------------
WRITE-CHAR [Function]
Args: (char &optional (stream *standard-output*))
Outputs CHAR and returns it.
------------------------------------------------------------------------------
WRITE-LINE [Function]
Args: (string &optional (stream *standard-output*)
&key (start 0) (end (length string)))
Outputs STRING and then outputs a newline character. Returns STRING.
------------------------------------------------------------------------------
WRITE-STRING [Function]
Args: (string &optional (stream *standard-output*)
&key (start 0) (end (length string)))
Outputs STRING and returns it.
------------------------------------------------------------------------------
WRITE-TO-STRING [Function]
Args: (object &key (escape *print-escape*) (radix *print-radix*)
(base *print-base*) (circle *print-circle*)
(pretty *print-pretty*) (level *print-level*)
(length *print-length*) (case *print-case*)
(array *print-array*) (gensym *print-gensym*))
Returns as a string the printed representation of OBJECT in the specified
mode. See the variable docs of *PRINT-...* for the mode.
------------------------------------------------------------------------------
Y-OR-N-P [Function]
Args: (&optional (format-string nil) &rest args)
Asks the user a question whose answer is either 'Y' or 'N'. If FORMAT-STRING
is non-NIL, then FRESH-LINE operation is performed, a message is printed as
if FORMAT-STRING and ARGs were given to FORMAT, and then a prompt
"(Y or N)" is printed. Otherwise, no prompt will appear.
------------------------------------------------------------------------------
YES-OR-NO-P [Function]
Args: (&optional (format-string nil) &rest args)
Asks the user a question whose answer is either 'YES' or 'NO'. If FORMAT-
STRING is non-NIL, then FRESH-LINE operation is performed, a message is
printed as if FORMAT-STRING and ARGs were given to FORMAT, and then a prompt
"(Yes or No)" is printed. Otherwise, no prompt will appear.
------------------------------------------------------------------------------
KCL Dictionary Page 86
------------------------------------------------------------------------------
ZEROP [Function]
Args: (number)
Returns T if NUMBER = 0; NIL otherwise.
------------------------------------------------------------------------------
si:ADDRESS [Function]
Args: (object)
KCL specific: Returns the address of the OBJECT as a fixnum. The address of
an object depends on the version of KCL. E.g. (SI:ADDRESS NIL) returns
1879062044 on KCL/AOSVS dated March 14, 1986.
------------------------------------------------------------------------------
si:ARGC [Function]
Args: ()
KCL specific: Returns the number of arguments on the command line that invoked
the KCL process.
------------------------------------------------------------------------------
si:ARGV [Function]
Args: (fixnum)
KCL specific: Returns the FIXNUM-th argument on the command line that invoked
the KCL process.
------------------------------------------------------------------------------
si:BDS-VAL [Function]
Args: (i)
KCL specific: Returns the value of the i-th entity in the bind stack.
------------------------------------------------------------------------------
si:BDS-VAR [Function]
Args: (i)
KCL specific: Returns the symbol of the i-th entity in the bind stack.
------------------------------------------------------------------------------
si:CATCH-BAD-SIGNALS [Function]
Args: ()
KCL/BSD specific: Installs a signal catcher for bad signals:
SIGILL, SIGIOT, SIGEMT, SIGBUS, SIGSEGV, SIGSYS.
The signal catcher, upon catching the signal, signals an error (and enter
the break-level). Since the internal memory of KCL may be broken, the user
should check the signal and exit from KCL if necessary. When the signal
is caught during garbage collection, KCL terminates immediately.
------------------------------------------------------------------------------
si:CHDIR [Function]
Args: (pathname)
KCL/UNIX specific: Changes the current working directory to the specified
pathname.
------------------------------------------------------------------------------
si:COMPILED-FUNCTION-NAME [Function]
Args: (compiled-function-object)
KCL specific: Returns the name of the COMPILED-FUNCTION-OBJECT.
------------------------------------------------------------------------------
KCL Dictionary Page 87
------------------------------------------------------------------------------
si:COPY-STREAM [Function]
Args: (in-stream out-stream)
KCL specific: Copies IN-STREAM to OUT-STREAM until the end-of-file on IN-
STREAM.
------------------------------------------------------------------------------
si:CREATE-IPC-FILE [Function]
Args: (pathname local-port-number)
KCL/AOSVS specific: Creates an IPC file with the name PATHNAME and with
the specified LOCAL-PORT-NUMBER. LOCAL-PORT-NUMBER should be a fixxnum.
------------------------------------------------------------------------------
si:*DEFAULT-TIME-ZONE* [Variable]
KCL specific: Holds the default time zone. The initial value of SI:*DEFAULT-
TIME-ZONE* is -9 (the time zone of Japan).
------------------------------------------------------------------------------
si:DISPLACED-ARRAY-P [Function]
Args (array)
KCL specific: Returns T if the ARRAY is a displaced array; NIL otherwise.
------------------------------------------------------------------------------
si:FRS-BDS [Function]
Args: (i)
KCL specific: Returns the bind stack index of the i-th entity in the frame
stack.
------------------------------------------------------------------------------
si:FRS-IHS [Function]
Args: (i)
KCL specific: Returns the invocation history stack index of the i-th entity
in the frame stack.
------------------------------------------------------------------------------
si:FRS-VS [Function]
Args: (i)
KCL specific: Returns the value stack index of the i-th entity in the frame
stack.
------------------------------------------------------------------------------
si:ERROR-SET [Function]
Args: (form)
KCL specific: Evaluates the FORM in the null environment. If the evaluation
of the FORM has successfully completed, SI:ERROR-SET returns NIL as the first
value and the result of the evaluation as the rest of the values. If, in the
course of the evaluation, a non-local jump from the FORM is atempted,
SI:ERROR-SET traps the jump and returns the corresponding jump tag as its
value.
------------------------------------------------------------------------------
si:FASLINK [Function]
Args: (file string)
KCL/BSD specific: Loads the FASL file FILE while linking the object files and
libraries specified by STRING. For example,
(faslink "foo.o" "bar.o boo.o -lpixrect")
loads foo.o while linking two object files (bar.o and boo.o) and the library
pixrect. Usually, foo.o consists of the C language interface for the
functions defined in the object files or the libraries.
------------------------------------------------------------------------------
KCL Dictionary Page 88
------------------------------------------------------------------------------
si:FIXNUMP [Function]
Args: (object)
KCL specific: Returns T if the OBJECT is a fixnum; NIL otherwise.
------------------------------------------------------------------------------
si:*GBC-MESSAGE* [Variable]
KCL specific: If the value of SI:*GBC-MESSAGE* is non-NIL, the garbage
collector prints some information on the terminal. Usually SI:*GBC-MESSAGE*
should be set NIL.
------------------------------------------------------------------------------
si:GET-STRING-INPUT-STREAM-INDEX [Function]
Args: (string-input-stream)
KCL specific: Returns the current index of the STRING-INPUT-STREAM.
------------------------------------------------------------------------------
si:GETENV [Function]
Args: (string)
KCL/UNIX specific: Returns the environment with the name STRING as a string;
if the environment specified by STRING is not found, returns NIL.
------------------------------------------------------------------------------
si:GET-HOLE-SIZE [Function]
Args: ()
KCL specific: Returns as a fixnum the size of the memory hole (in pages).
------------------------------------------------------------------------------
si:*IGNORE-EOF-ON-TERMINAL-IO* [Variable]
KCL specific: If the value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is non-NIL, KCL
ignores the eof-character (usually ^D) on the terminal and the terminal never
becomes end-of-file. The default value of SI:*IGNORE-EOF-ON-TERMINAL-IO* is
NIL.
------------------------------------------------------------------------------
si:IHS-FUN [Function]
Args: (i)
KCL specific: Returns the function value of the i-th entity in the invocation
history stack.
------------------------------------------------------------------------------
si:IHS-VS [Function]
Args: (i)
KCL specific: Returns the value stack index of the i-th entity in the
invocation history stack.
------------------------------------------------------------------------------
si:ILKUP [Function]
Args: (pathname)
KCL/AOSVS specific: Returns the global port number of the IPC file specified
by the PATHNAME.
------------------------------------------------------------------------------
si:*INDENT-FORMATTED-OUTPUT* [Variable]
KCL specific: The FORMAT directive ~% indents the next line if the value of
this variable is non-NIL. If NIL, ~% simply does Newline.
------------------------------------------------------------------------------
KCL Dictionary Page 89
------------------------------------------------------------------------------
si:INIT-SYSTEM [Function]
Args: ()
KCL specific: Initializes the library and the compiler of KCL. Since they
have already been initialized in the standard image of KCL, calling SI:INIT-
SYSTEM will cause an error.
------------------------------------------------------------------------------
si:*INTERRUPT-ENABLE* [Variable]
KCL specific: If the value of SI:*INTERRUPT-ENABLE* is non-NIL, KCL signals
an error on the terminal interrupt (this is the default case). If it is NIL,
KCL ignores the interrupt and assigns T to SI:*INTERRUPT-ENABLE*.
------------------------------------------------------------------------------
si:IREC [Function]
Args: (global-port-number local-port-number string)
KCL/AOSVS specific: Receives a message from the specified port into the
STRING. GLOBAL-PORT-NUMBER and LOCAL-PORT-NUMBER should be fixnums. The
STRING should have a fill-pointer.
------------------------------------------------------------------------------
si:ISEND [Function]
Args: (global-port-number local-port-number string)
KCL/AOSVS specific: Sends a message in the STRING to the specified port.
GLOBAL-PORT-NUMBER and LOCAL-PORT-NUMBER should be fixnums.
------------------------------------------------------------------------------
si:*LISP-MAXPAGES* [Variable]
KCL specific: Holds the maximum number of pages (1 page = 2048 bytes) for the
KCL process. The result of changing the value of SI:*LISP-MAXPAGES* is
unpredictable.
------------------------------------------------------------------------------
si:*MAKE-CONSTANT [Function]
Args: (symbol value)
KCL specific: Makes the SYMBOL a constant with the specified VALUE.
------------------------------------------------------------------------------
si:*MAKE-SPECIAL [Function]
Args (symbol)
KCL specific: Makes the SYMBOL globally special.
------------------------------------------------------------------------------
si:MAKE-STRING-OUTPUT-STREAM-FROM-STRING [Function]
Args (string)
KCL specific: Creates a string-output-stream corresponding to the STRING and
returns it. The STRING should have a fill-pointer.
------------------------------------------------------------------------------
si:NANI [Function]
Args: (fixnum)
KCL specific: Returns the object in the address FIXNUM. This function is
the inverse of SI:ADDRESS. Although SI:ADDRESS is a harmless operation,
SI:NANI is quite dangerous and should be used with care.
------------------------------------------------------------------------------
KCL Dictionary Page 90
------------------------------------------------------------------------------
si:*NOTIFY-GBC* [Variable]
KCL specific: If the value of this variable is non-NIL, then the garbage
collector notifies that it begins to run whenever it is invoked. Otherwise,
garbage collection begins silently.
------------------------------------------------------------------------------
si:OUTPUT-STREAM-STRING [Function]
Args: (string-output-stream)
KCL specific: Returns the string corresponding to the STRING-OUTPUT-STREAM.
------------------------------------------------------------------------------
si:RESET-GBC-COUNT [Function]
Args: ()
KCL specific: Resets the counter of the garbage collector that records how
many times the garbage collector has been called for each implementation
type.
------------------------------------------------------------------------------
si:RESET-STACK-LIMITS [Function]
Args: ()
KCL specific: Resets the stack limits to the normal state. When a stack has
overflowed, KCL extends the limit for the stack in order to execute the error
handler. After processing the error, KCL resets the stack limit by calling
SI:RESET-STACK-LIMITS.
------------------------------------------------------------------------------
si:SAVE-SYSTEM [Function]
Args: (pathname)
KCL specific: Saves the current KCL core imange into a program file specified
by PATHNAME. This function differs from SAVE in that the contiguous and
relocatable areas are made permanent in the saved image. Usually the
standard image of KCL interpreter/compiler is saved by SI:SAVE-SYSTEM.
------------------------------------------------------------------------------
si:SET-HOLE-SIZE [Function]
Args: (fixnum)
KCL specific: Sets the size of the memory hole (in pages).
------------------------------------------------------------------------------
si:SPECIALP [Function]
Args: (symbol)
KCL specific: Returns T if the SYMBOL is a globally special variable; NIL
otherwise.
------------------------------------------------------------------------------
si:STRING-CONCATENATE [Function]
Args: (&rest strings)
KCL specific: Returns the result of concatenating the given STRINGS.
------------------------------------------------------------------------------
si:STRING-TO-OBJECT [Function]
Args: (string)
KCL specific: (SI:STRING-TO-OBJECT STRING) is equivalent to
(READ-FROM-STRING STRING), but much faster.
------------------------------------------------------------------------------
KCL Dictionary Page 91
------------------------------------------------------------------------------
si:STRUCTUREP [Function]
Args: (object)
KCL specific: Returns T if the OBJECT is a structure; NIL otherwise.
------------------------------------------------------------------------------
si:*SYSTEM-DIRECTORY* [Variable]
KCL specific: Holds the name of the system directory of KCL.
------------------------------------------------------------------------------
si:TOP-LEVEL [Function]
Args: ()
KCL specific: Starts the standard top-level listner of KCL. When the KCL
process is invoked, it calls SI:TOP-LEVEL by (FUNCALL 'SI:TOP-LEVEL).
To change the top-level of KCL, redefine SI:TOP-LEVEL and save the core
imange in a file. When the saved imange is invoked, it will start the
redefined top-level.
------------------------------------------------------------------------------
si:UNIVERSAL-ERROR-HANDLER [Function]
Args: (error-name correctable function-name
continue-format-string error-format-string
&rest args)
KCL specific: Starts the error handler of KCL. When an error is detected,
KCL calls SI:UNIVERSAL-ERROR-HANDLER with the specified arguments.
ERROR-NAME is the name of the error. CORRECTABLE is T for a correctable
error and NIL for a fatal error. FUNCTION-NAME is the name of the function
that caused the error. CONTINUE-FORMAT-STRING and ERROR-FORMAT-STRING are
the format strings of the error message. ARGS are the arguments to the
format strings.
To change the error handler of KCL, redefine SI:UNIVERSAL-ERROR-
HANDLER.
------------------------------------------------------------------------------
si:UNCATCH-BAD-SIGNALS [Function]
Args: ()
KCL/BSD specific: Undoes the effect of SI:CATCH-BAD-SIGNALS.
------------------------------------------------------------------------------
si:VS [Function]
Args: (i)
KCL specific: Returns the i-th entity in the value stack.
------------------------------------------------------------------------------
*DEFAULT-MESSAGE-FILE* [Variable]
KCL specific: Gives the default value of the :MESSAGE-FILE parameter to
COMPILE-FILE. The initial value is NIL, meaning that no log file is
prepared.
------------------------------------------------------------------------------
KCL Dictionary Page 92
ABS ARGUMENTS
ABS 2 CALL-ARGUMENTS-LIMIT 12
ACONS ARGV
ACONS 2 ARGV 86
ACOS ARRAY
ACOS 2 ADJUST-ARRAY 3
ACOSH ADJUSTABLE-ARRAY-P 3
ACOSH 3 ARRAY 5
ADDRESS ARRAY-DIMENSION 5
ADDRESS 86 ARRAY-DIMENSION-LIMIT 5
ADJOIN ARRAY-DIMENSIONS 5
ADJOIN 3 ARRAY-ELEMENT-TYPE 5
ADJUST ARRAY-HAS-FILL-POINTER-P 5
ADJUST-ARRAY 3 ARRAY-IN-BOUNDS-P 5
ADJUSTABLE ARRAY-RANK 5
ADJUSTABLE-ARRAY-P 3 ARRAY-RANK-LIMIT 5
ALIST ARRAY-ROW-MAJOR-INDEX 5
COPY-ALIST 20 ARRAY-TOTAL-SIZE 6
ALL ARRAY-TOTAL-SIZE-LIMIT 6
DO-ALL-SYMBOLS 28 MAKE-ARRAY 48
FIND-ALL-SYMBOLS 34 *PRINT-ARRAY* 61
LIST-ALL-PACKAGES 45 SIMPLE-ARRAY 72
ALLOCATABLE DISPLACED-ARRAY-P 87
MAXIMUM-ALLOCATABLE-PAGES 51 ARRAYP
ALLOCATE ARRAYP 6
ALLOCATE 3 ASH
ALLOCATE-CONTIGUOUS-PAGES 3 ASH 6
ALLOCATE-RELOCATABLE-PAGES 3 ASIN
ALLOCATED ASIN 6
ALLOCATED-CONTIGUOUS-PAGES 3 ASINH
ALLOCATED-PAGES 3 ASINH 6
ALLOCATED-RELOCATABLE-PAGES 4 ASSERT
ALPHA ASSERT 6
ALPHA-CHAR-P 4 ASSOC
ALPHANUMERICP ASSOC 6
ALPHANUMERICP 4 ASSOC-IF 6
AND ASSOC-IF-NOT 6
AND 4 ATAN
BIT-AND 7 ATAN 6
BOOLE-AND 9 ATANH
ANDC1 ATANH 7
BIT-ANDC1 7 ATOM
BOOLE-ANDC1 9 ATOM 7
ANDC2 AUTHOR
BIT-ANDC2 7 FILE-AUTHOR 33
BOOLE-ANDC2 9 BAD
APPEND CATCH-BAD-SIGNALS 86
APPEND 4 UNCATCH-BAD-SIGNALS 91
APPLY BASE
APPLY 4 *PRINT-BASE* 61
APPLYHOOK *READ-BASE* 64
APPLYHOOK 4 BDS
*APPLYHOOK* 4 BDS-VAL 86
APROPOS BDS-VAR 86
APROPOS 4 FRS-BDS 87
APROPOS-LIST 4 BIGNUM
AREF BIGNUM 7
AREF 5 BIND
ARGC MULTIPLE-VALUE-BIND 53
ARGC 86 BIT
KCL Dictionary Page 93
BIT 7 BY 11
BIT-AND 7 PACKAGE-USED-BY-LIST 58
BIT-ANDC1 7 BYE
BIT-ANDC2 7 BYE 11
BIT-EQV 7 BYTE
BIT-IOR 7 BYTE 11
BIT-NAND 8 BYTE-POSITION 11
BIT-NOR 8 BYTE-SIZE 11
BIT-NOT 8 READ-BYTE 65
BIT-ORC1 8 WRITE-BYTE 85
BIT-ORC2 8 C1
BIT-VECTOR 8 BOOLE-C1 9
BIT-VECTOR-P 8 C2
BIT-XOR 8 BOOLE-C2 9
CHAR-BIT 14 CAAAAR
CHAR-CONTROL-BIT 15 CAAAAR 11
CHAR-HYPER-BIT 15 CAAADR
CHAR-META-BIT 15 CAAADR 11
CHAR-SUPER-BIT 16 CAAAR
SET-CHAR-BIT 70 CAAAR 11
SIMPLE-BIT-VECTOR 72 CAADAR
SIMPLE-BIT-VECTOR-P 72 CAADAR 11
BITS CAADDR
CHAR-BITS 14 CAADDR 11
CHAR-BITS-LIMIT 14 CAADR
BLOCK CAADR 11
BLOCK 9 CAAR
BOOLE CAAR 11
BOOLE 9 CADAAR
BOOLE-1 9 CADAAR 12
BOOLE-2 9 CADADR
BOOLE-AND 9 CADADR 12
BOOLE-ANDC1 9 CADAR
BOOLE-ANDC2 9 CADAR 12
BOOLE-C1 9 CADDAR
BOOLE-C2 9 CADDAR 12
BOOLE-CLR 9 CADDDR
BOOLE-EQV 9 CADDDR 12
BOOLE-IOR 9 CADDR
BOOLE-NAND 10 CADDR 12
BOOLE-NOR 10 CADR
BOOLE-ORC1 10 CADR 12
BOOLE-ORC2 10 CALL
BOOLE-SET 10 CALL-ARGUMENTS-LIMIT 12
BOOLE-XOR 10 MULTIPLE-VALUE-CALL 53
BOTH CAPITALIZE
BOTH-CASE-P 10 NSTRING-CAPITALIZE 55
BOUNDP STRING-CAPITALIZE 75
BOUNDP 10 CAR
BOUNDS CAR 12
ARRAY-IN-BOUNDS-P 5 CASE
BREAK BOTH-CASE-P 10
BREAK 10 CASE 12
*BREAK-ENABLE* 10 LOWER-CASE-P 47
*BREAK-ON-WARNINGS* 10 *PRINT-CASE* 61
BROADCAST UPPER-CASE-P 83
MAKE-BROADCAST-STREAM 48 CATCH
BUTLAST CATCH 12
BUTLAST 10 CATCH-BAD-SIGNALS 86
BY CCASE
KCL Dictionary Page 94
CCASE 13 CHAR< 16
CDAAAR CHAR<= 16
CDAAAR 13 CHAR= 16
CDAADR CHAR> 17
CDAADR 13 CHAR>= 17
CDAAR CODE-CHAR 18
CDAAR 13 DIGIT-CHAR 27
CDADAR DIGIT-CHAR-P 28
CDADAR 13 GRAPHIC-CHAR-P 39
CDADDR INT-CHAR 41
CDADDR 13 MAKE-CHAR 48
CDADR NAME-CHAR 53
CDADR 13 PEEK-CHAR 59
CDAR READ-CHAR 65
CDAR 13 READ-CHAR-NO-HANG 65
CDDAAR SET-CHAR-BIT 70
CDDAAR 13 SET-SYNTAX-FROM-CHAR 70
CDDADR STANDARD-CHAR 74
CDDADR 13 STANDARD-CHAR-P 74
CDDAR STRING-CHAR 76
CDDAR 13 STRING-CHAR-P 76
CDDDAR UNREAD-CHAR 82
CDDDAR 14 WRITE-CHAR 85
CDDDDR CHARACTER
CDDDDR 14 CHARACTER 17
CDDDR GET-DISPATCH-MACRO-CHARACTER 38
CDDDR 14 GET-MACRO-CHARACTER 38
CDDR MAKE-DISPATCH-MACRO-CHARACTER 48
CDDR 14 SET-DISPATCH-MACRO-CHARACTER 70
CDR SET-MACRO-CHARACTER 70
CDR 14 CHARACTERP
CEILING CHARACTERP 17
CEILING 14 CHDIR
CERROR CHDIR 86
CERROR 14 CHECK
CHAR CHECK-TYPE 17
ALPHA-CHAR-P 4 CIRCLE
CHAR 14 *PRINT-CIRCLE* 61
CHAR-BIT 14 CIS
CHAR-BITS 14 CIS 17
CHAR-BITS-LIMIT 14 CLEAR
CHAR-CODE 15 CLEAR-INPUT 17
CHAR-CODE-LIMIT 15 CLEAR-OUTPUT 18
CHAR-CONTROL-BIT 15 CLINES
CHAR-DOWNCASE 15 CLINES 18
CHAR-EQUAL 15 CLOSE
CHAR-FONT 15 CLOSE 18
CHAR-FONT-LIMIT 15 CLR
CHAR-GREATERP 15 BOOLE-CLR 9
CHAR-HYPER-BIT 15 CLRHASH
CHAR-INT 15 CLRHASH 18
CHAR-LESSP 15 CODE
CHAR-META-BIT 15 CHAR-CODE 15
CHAR-NAME 16 CHAR-CODE-LIMIT 15
CHAR-NOT-EQUAL 16 CODE-CHAR 18
CHAR-NOT-GREATERP 16 COERCE
CHAR-NOT-LESSP 16 COERCE 18
CHAR-SUPER-BIT 16 COMMON
CHAR-UPCASE 16 COMMON 18
CHAR/= 16 COMMONP
KCL Dictionary Page 95
COMMONP 18 DATE
COMPILE FILE-WRITE-DATE 33
COMPILE 18 DEBUG
COMPILE-FILE 19 *DEBUG-IO* 21
*EVAL-WHEN-COMPILE* 31 DECF
COMPILED DECF 21
COMPILED-FUNCTION 19 DECLARE
COMPILED-FUNCTION-P 19 DECLARE 22
COMPILED-FUNCTION-NAME 86 DECODE
COMPILER DECODE-FLOAT 22
COMPILER-LET 19 DECODE-UNIVERSAL-TIME 22
COMPLEX INTEGER-DECODE-FLOAT 41
COMPLEX 19 DECODED
COMPLEXP GET-DECODED-TIME 38
COMPLEXP 19 DEFAULT
CONCATENATE *DEFAULT-PATHNAME-DEFAULTS* 22
CONCATENATE 19 *READ-DEFAULT-FLOAT-FORMAT* 65
STRING-CONCATENATE 90 *DEFAULT-TIME-ZONE* 87
CONCATENATED *DEFAULT-MESSAGE-FILE* 91
MAKE-CONCATENATED-STREAM 48 DEFAULTS
COND *DEFAULT-PATHNAME-DEFAULTS* 22
COND 20 DEFCFUN
CONJUGATE DEFCFUN 23
CONJUGATE 20 DEFCONSTANT
CONS DEFCONSTANT 23
CONS 20 DEFENTRY
CONSP DEFENTRY 23
CONSP 20 DEFINE
CONSTANT DEFINE-MODIFY-MACRO 23
*MAKE-CONSTANT 89 DEFINE-SETF-METHOD 24
CONSTANTP DEFLA
CONSTANTP 20 DEFLA 24
CONTIGUOUS DEFMACRO
ALLOCATE-CONTIGUOUS-PAGES 3 DEFMACRO 25
ALLOCATED-CONTIGUOUS-PAGES 3 DEFPARAMETER
MAXIMUM-CONTIGUOUS-PAGES 51 DEFPARAMETER 25
CONTROL DEFSETF
CHAR-CONTROL-BIT 15 DEFSETF 25
COPY DEFSTRUCT
COPY-ALIST 20 DEFSTRUCT 26
COPY-LIST 20 DEFTYPE
COPY-READTABLE 20 DEFTYPE 26
COPY-SEQ 20 DEFUN
COPY-SYMBOL 21 DEFUN 26
COPY-TREE 21 DEFVAR
COPY-STREAM 87 DEFVAR 26
COS DELETE
COS 21 DELETE 27
COSH DELETE-DUPLICATES 27
COSH 21 DELETE-FILE 27
COUNT DELETE-IF 27
COUNT 21 DELETE-IF-NOT 27
COUNT-IF 21 DELIMITED
COUNT-IF-NOT 21 READ-DELIMITED-LIST 65
HASH-TABLE-COUNT 39 DENOMINATOR
RESET-GBC-COUNT 90 DENOMINATOR 27
CREATE DEPOSIT
CREATE-IPC-FILE 87 DEPOSIT-FIELD 27
CTYPECASE DESCRIBE
CTYPECASE 21 DESCRIBE 27
KCL Dictionary Page 96
DEVICE ECHO
PATHNAME-DEVICE 59 MAKE-ECHO-STREAM 49
DIFFERENCE ED
NSET-DIFFERENCE 55 ED 30
SET-DIFFERENCE 70 EIGHTH
DIGIT EIGHTH 30
DIGIT-CHAR 27 ELEMENT
DIGIT-CHAR-P 28 ARRAY-ELEMENT-TYPE 5
DIGITS STREAM-ELEMENT-TYPE 75
FLOAT-DIGITS 35 ELT
DIMENSION ELT 30
ARRAY-DIMENSION 5 ENABLE
ARRAY-DIMENSION-LIMIT 5 *BREAK-ENABLE* 10
DIMENSIONS *INTERRUPT-ENABLE* 89
ARRAY-DIMENSIONS 5 ENCODE
DIRECTORY ENCODE-UNIVERSAL-TIME 30
DIRECTORY 28 ENDP
DIRECTORY-NAMESTRING 28 ENDP 30
PATHNAME-DIRECTORY 59 ENOUGH
*SYSTEM-DIRECTORY* 91 ENOUGH-NAMESTRING 30
DISASSEMBLE EOF
DISASSEMBLE 28 *IGNORE-EOF-ON-TERMINAL-IO* 88
DISPATCH EPSILON
GET-DISPATCH-MACRO-CHARACTER 38 DOUBLE-FLOAT-EPSILON 29
MAKE-DISPATCH-MACRO-CHARACTER 48 DOUBLE-FLOAT-NEGATIVE-EPSILON 29
SET-DISPATCH-MACRO-CHARACTER 70 LONG-FLOAT-EPSILON 47
DISPLACED LONG-FLOAT-NEGATIVE-EPSILON 47
DISPLACED-ARRAY-P 87 SHORT-FLOAT-EPSILON 71
DO SHORT-FLOAT-NEGATIVE-EPSILON 72
DO 28 SINGLE-FLOAT-EPSILON 72
DO* 28 SINGLE-FLOAT-NEGATIVE-EPSILON 73
DO-ALL-SYMBOLS 28 EQ
DO-EXTERNAL-SYMBOLS 28 EQ 30
DO-SYMBOLS 29 EQL
DOCUMENTATION EQL 30
DOCUMENTATION 29 EQUAL
DOLIST CHAR-EQUAL 15
DOLIST 29 CHAR-NOT-EQUAL 16
DOTIMES EQUAL 30
DOTIMES 29 STRING-EQUAL 76
DOUBLE STRING-NOT-EQUAL 76
DOUBLE-FLOAT-EPSILON 29 TREE-EQUAL 81
DOUBLE-FLOAT-NEGATIVE-EPSILON 29 EQUALP
LEAST-NEGATIVE-DOUBLE-FLOAT 43 EQUALP 31
LEAST-POSITIVE-DOUBLE-FLOAT 43 EQV
MOST-NEGATIVE-DOUBLE-FLOAT 52 BIT-EQV 7
MOST-POSITIVE-DOUBLE-FLOAT 53 BOOLE-EQV 9
DOWNCASE ERROR
CHAR-DOWNCASE 15 ERROR 31
NSTRING-DOWNCASE 55 *ERROR-OUTPUT* 31
STRING-DOWNCASE 76 ERROR-SET 87
DPB UNIVERSAL-ERROR-HANDLER 91
DPB 29 ESCAPE
DRIBBLE *PRINT-ESCAPE* 61
DRIBBLE 29 ETYPECASE
DUPLICATES ETYPECASE 31
DELETE-DUPLICATES 27 EVAL
REMOVE-DUPLICATES 67 EVAL 31
ECASE EVAL-WHEN 31
ECASE 29 *EVAL-WHEN-COMPILE* 31
KCL Dictionary Page 97
EVALHOOK FINISH-OUTPUT 34
EVALHOOK 31 FIRST
*EVALHOOK* 31 FIRST 34
EVENP FIXNUM
EVENP 32 FIXNUM 34
EVERY MOST-NEGATIVE-FIXNUM 52
EVERY 32 MOST-POSITIVE-FIXNUM 53
EXCLUSIVE FIXNUMP
NSET-EXCLUSIVE-OR 55 FIXNUMP 88
SET-EXCLUSIVE-OR 70 FLET
EXP FLET 34
EXP 32 FLOAT
EXPORT DECODE-FLOAT 22
EXPORT 32 DOUBLE-FLOAT-EPSILON 29
EXPT DOUBLE-FLOAT-NEGATIVE-EPSILON 29
EXPT 32 FLOAT 35
EXTEND FLOAT-DIGITS 35
VECTOR-PUSH-EXTEND 84 FLOAT-PRECISION 35
EXTERNAL FLOAT-RADIX 35
DO-EXTERNAL-SYMBOLS 28 FLOAT-SIGN 35
FASLINK INTEGER-DECODE-FLOAT 41
FASLINK 87 LEAST-NEGATIVE-DOUBLE-FLOAT 43
FBOUNDP LEAST-NEGATIVE-LONG-FLOAT 43
FBOUNDP 32 LEAST-NEGATIVE-SHORT-FLOAT 43
FCEILING LEAST-NEGATIVE-SINGLE-FLOAT 43
FCEILING 32 LEAST-POSITIVE-DOUBLE-FLOAT 43
FEATURES LEAST-POSITIVE-LONG-FLOAT 43
*FEATURES* 32 LEAST-POSITIVE-SHORT-FLOAT 43
FFLOOR LEAST-POSITIVE-SINGLE-FLOAT 44
FFLOOR 33 LONG-FLOAT-EPSILON 47
FIELD LONG-FLOAT-NEGATIVE-EPSILON 47
DEPOSIT-FIELD 27 MOST-NEGATIVE-DOUBLE-FLOAT 52
MASK-FIELD 51 MOST-NEGATIVE-LONG-FLOAT 52
FIFTH MOST-NEGATIVE-SHORT-FLOAT 52
FIFTH 33 MOST-NEGATIVE-SINGLE-FLOAT 52
FILE MOST-POSITIVE-DOUBLE-FLOAT 53
COMPILE-FILE 19 MOST-POSITIVE-LONG-FLOAT 53
DELETE-FILE 27 MOST-POSITIVE-SHORT-FLOAT 53
FILE-AUTHOR 33 MOST-POSITIVE-SINGLE-FLOAT 53
FILE-LENGTH 33 *READ-DEFAULT-FLOAT-FORMAT* 65
FILE-NAMESTRING 33 SCALE-FLOAT 69
FILE-POSITION 33 SHORT-FLOAT-EPSILON 71
FILE-WRITE-DATE 33 SHORT-FLOAT-NEGATIVE-EPSILON 72
PROBE-FILE 62 SINGLE-FLOAT-EPSILON 72
RENAME-FILE 67 SINGLE-FLOAT-NEGATIVE-EPSILON 73
WITH-OPEN-FILE 84 FLOATP
CREATE-IPC-FILE 87 FLOATP 35
*DEFAULT-MESSAGE-FILE* 91 FLOOR
FILL FLOOR 36
ARRAY-HAS-FILL-POINTER-P 5 FMAKUNBOUND
FILL 33 FMAKUNBOUND 36
FILL-POINTER 33 FONT
FIND CHAR-FONT 15
FIND 33 CHAR-FONT-LIMIT 15
FIND-ALL-SYMBOLS 34 FORCE
FIND-IF 34 FORCE-OUTPUT 36
FIND-IF-NOT 34 FORM
FIND-PACKAGE 34 SPECIAL-FORM-P 74
FIND-SYMBOL 34 FORMAT
FINISH FORMAT 36
KCL Dictionary Page 98
*READ-DEFAULT-FLOAT-FORMAT* 65 GETENV
FORMATTED GETENV 88
*INDENT-FORMATTED-OUTPUT* 88 GETF
FOURTH GETF 39
FOURTH 36 GETHASH
FRESH GETHASH 39
FRESH-LINE 36 GO
FROM GO 39
READ-FROM-STRING 65 GRAPHIC
RETURN-FROM 68 GRAPHIC-CHAR-P 39
SET-SYNTAX-FROM-CHAR 70 GREATERP
WITH-INPUT-FROM-STRING 84 CHAR-GREATERP 15
make-string-output-stream-from.. 89 CHAR-NOT-GREATERP 16
FROUND STRING-GREATERP 76
FROUND 36 STRING-NOT-GREATERP 76
FRS HANDLER
FRS-BDS 87 UNIVERSAL-ERROR-HANDLER 91
FRS-IHS 87 HANG
FRS-VS 87 READ-CHAR-NO-HANG 65
FTRUNCATE HAS
FTRUNCATE 37 ARRAY-HAS-FILL-POINTER-P 5
FUN HASH
IHS-FUN 88 HASH-TABLE 39
FUNCALL HASH-TABLE-COUNT 39
FUNCALL 37 HASH-TABLE-P 40
FUNCTION MAKE-HASH-TABLE 49
COMPILED-FUNCTION 19 HELP
COMPILED-FUNCTION-P 19 HELP 40
FUNCTION 37 HELP* 40
MACRO-FUNCTION 47 HOLE
SYMBOL-FUNCTION 79 GET-HOLE-SIZE 88
COMPILED-FUNCTION-NAME 86 SET-HOLE-SIZE 90
FUNCTIONP HOMEDIR
FUNCTIONP 37 USER-HOMEDIR-PATHNAME 83
GBC HOOK
GBC 37 *MACROEXPAND-HOOK* 48
*GBC-MESSAGE* 88 HOST
*NOTIFY-GBC* 90 HOST-NAMESTRING 40
RESET-GBC-COUNT 90 PATHNAME-HOST 59
GCD HYPER
GCD 37 CHAR-HYPER-BIT 15
GENSYM IDENTITY
GENSYM 37 IDENTITY 40
*PRINT-GENSYM* 61 IF
GENTEMP ASSOC-IF 6
GENTEMP 38 ASSOC-IF-NOT 6
GET COUNT-IF 21
GET 38 COUNT-IF-NOT 21
GET-DECODED-TIME 38 DELETE-IF 27
GET-DISPATCH-MACRO-CHARACTER 38 DELETE-IF-NOT 27
GET-INTERNAL-REAL-TIME 38 FIND-IF 34
GET-INTERNAL-RUN-TIME 38 FIND-IF-NOT 34
GET-MACRO-CHARACTER 38 IF 40
GET-OUTPUT-STREAM-STRING 38 MEMBER-IF 51
GET-PROPERTIES 38 MEMBER-IF-NOT 51
GET-SETF-METHOD 39 NSUBST-IF 55
GET-SETF-METHOD-MULTIPLE-VALUE 39 NSUBST-IF-NOT 55
GET-UNIVERSAL-TIME 39 NSUBSTITUTE-IF 56
GET-STRING-INPUT-STREAM-INDEX 88 NSUBSTITUTE-IF-NOT 56
GET-HOLE-SIZE 88 POSITION-IF 60
KCL Dictionary Page 99
POSITION-IF-NOT 60 INTERN 42
RASSOC-IF 64 INTERNAL
RASSOC-IF-NOT 64 GET-INTERNAL-REAL-TIME 38
REMOVE-IF 67 GET-INTERNAL-RUN-TIME 38
REMOVE-IF-NOT 67 INTERNAL-TIME-UNITS-PER-SECOND 42
SUBST-IF 78 INTERRUPT
SUBST-IF-NOT 78 *INTERRUPT-ENABLE* 89
SUBSTITUTE-IF 79 INTERSECTION
SUBSTITUTE-IF-NOT 79 INTERSECTION 42
IGNORE IO
*IGNORE-MAXIMUM-PAGES* 40 *DEBUG-IO* 21
*IGNORE-EOF-ON-TERMINAL-IO* 88 *QUERY-IO* 63
IHS *TERMINAL-IO* 80
FRS-IHS 87 *IGNORE-EOF-ON-TERMINAL-IO* 88
IHS-FUN 88 IOR
IHS-VS 88 BIT-IOR 7
ILKUP BOOLE-IOR 9
ILKUP 88 IPC
IMAGPART CREATE-IPC-FILE 87
IMAGPART 40 IREC
IMPLEMENTATION IREC 89
LISP-IMPLEMENTATION-TYPE 44 ISEND
LISP-IMPLEMENTATION-VERSION 44 ISEND 89
IMPORT ISQRT
IMPORT 40 ISQRT 42
SHADOWING-IMPORT 71 KEYWORDP
IN KEYWORDP 42
ARRAY-IN-BOUNDS-P 5 KEYWORDS
IN-PACKAGE 41 LAMBDA-LIST-KEYWORDS 42
INCF LABELS
INCF 41 LABELS 42
INDENT LAMBDA
*INDENT-FORMATTED-OUTPUT* 88 LAMBDA-LIST-KEYWORDS 42
INDEX LAMBDA-PARAMETERS-LIMIT 42
ARRAY-ROW-MAJOR-INDEX 5 LAST
GET-STRING-INPUT-STREAM-INDEX 88 LAST 43
INIT LAST-TERMINATION-MESSAGE 43
INIT-SYSTEM 89 LCM
INPUT LCM 43
CLEAR-INPUT 17 LDB
INPUT-STREAM-P 41 LDB 43
MAKE-STRING-INPUT-STREAM 49 LDB-TEST 43
*STANDARD-INPUT* 75 LDIFF
WITH-INPUT-FROM-STRING 84 LDIFF 43
GET-STRING-INPUT-STREAM-INDEX 88 LEAST
INSPECT LEAST-NEGATIVE-DOUBLE-FLOAT 43
INSPECT 41 LEAST-NEGATIVE-LONG-FLOAT 43
INSTANCE LEAST-NEGATIVE-SHORT-FLOAT 43
MACHINE-INSTANCE 47 LEAST-NEGATIVE-SINGLE-FLOAT 43
INT LEAST-POSITIVE-DOUBLE-FLOAT 43
CHAR-INT 15 LEAST-POSITIVE-LONG-FLOAT 43
INT-CHAR 41 LEAST-POSITIVE-SHORT-FLOAT 43
INTEGER LEAST-POSITIVE-SINGLE-FLOAT 44
INTEGER 41 LEFT
INTEGER-DECODE-FLOAT 41 STRING-LEFT-TRIM 76
INTEGER-LENGTH 42 LENGTH
PARSE-INTEGER 58 FILE-LENGTH 33
INTEGERP INTEGER-LENGTH 42
INTEGERP 42 LENGTH 44
INTERN LIST-LENGTH 45
KCL Dictionary Page 100
*PRINT-LENGTH* 61 LOGANDC1
LESSP LOGANDC1 45
CHAR-LESSP 15 LOGANDC2
CHAR-NOT-LESSP 16 LOGANDC2 46
STRING-LESSP 76 LOGBITP
STRING-NOT-LESSP 77 LOGBITP 46
LET LOGCOUNT
COMPILER-LET 19 LOGCOUNT 46
LET 44 LOGEQV
LET* 44 LOGEQV 46
LEVEL LOGIOR
*PRINT-LEVEL* 61 LOGIOR 46
TOP-LEVEL 91 LOGNAND
LIMIT LOGNAND 46
ARRAY-DIMENSION-LIMIT 5 LOGNOR
ARRAY-RANK-LIMIT 5 LOGNOR 46
ARRAY-TOTAL-SIZE-LIMIT 6 LOGNOT
CALL-ARGUMENTS-LIMIT 12 LOGNOT 46
CHAR-BITS-LIMIT 14 LOGORC1
CHAR-CODE-LIMIT 15 LOGORC1 46
CHAR-FONT-LIMIT 15 LOGORC2
LAMBDA-PARAMETERS-LIMIT 42 LOGORC2 46
MULTIPLE-VALUES-LIMIT 53 LOGTEST
LIMITS LOGTEST 46
RESET-STACK-LIMITS 90 LOGXOR
LINE LOGXOR 47
FRESH-LINE 36 LONG
READ-LINE 65 LEAST-NEGATIVE-LONG-FLOAT 43
WRITE-LINE 85 LEAST-POSITIVE-LONG-FLOAT 43
LISP LONG-FLOAT-EPSILON 47
LISP-IMPLEMENTATION-TYPE 44 LONG-FLOAT-NEGATIVE-EPSILON 47
LISP-IMPLEMENTATION-VERSION 44 LONG-SITE-NAME 47
*LISP-MAXPAGES* 89 MOST-NEGATIVE-LONG-FLOAT 52
LIST MOST-POSITIVE-LONG-FLOAT 53
APROPOS-LIST 4 LOOP
COPY-LIST 20 LOOP 47
LAMBDA-LIST-KEYWORDS 42 LOWER
LIST 44 LOWER-CASE-P 47
LIST* 45 MACHINE
LIST-ALL-PACKAGES 45 MACHINE-INSTANCE 47
LIST-LENGTH 45 MACHINE-TYPE 47
MAKE-LIST 49 MACHINE-VERSION 47
MULTIPLE-VALUE-LIST 53 MACRO
PACKAGE-USE-LIST 58 DEFINE-MODIFY-MACRO 23
PACKAGE-USED-BY-LIST 58 GET-DISPATCH-MACRO-CHARACTER 38
READ-DELIMITED-LIST 65 GET-MACRO-CHARACTER 38
VALUES-LIST 83 MACRO-FUNCTION 47
LISTEN MAKE-DISPATCH-MACRO-CHARACTER 48
LISTEN 45 SET-DISPATCH-MACRO-CHARACTER 70
LISTP SET-MACRO-CHARACTER 70
LISTP 45 MACROEXPAND
LOAD MACROEXPAND 48
LOAD 45 MACROEXPAND-1 48
*LOAD-VERBOSE* 45 *MACROEXPAND-HOOK* 48
LOCALLY MACROLET
LOCALLY 45 MACROLET 48
LOG MAJOR
LOG 45 ARRAY-ROW-MAJOR-INDEX 5
LOGAND MAKE
LOGAND 45 MAKE-ARRAY 48
KCL Dictionary Page 101
MAKE-BROADCAST-STREAM 48 META
MAKE-CHAR 48 CHAR-META-BIT 15
MAKE-CONCATENATED-STREAM 48 METHOD
MAKE-DISPATCH-MACRO-CHARACTER 48 DEFINE-SETF-METHOD 24
MAKE-ECHO-STREAM 49 GET-SETF-METHOD 39
MAKE-HASH-TABLE 49 GET-SETF-METHOD-MULTIPLE-VALUE 39
MAKE-LIST 49 MIN
MAKE-PACKAGE 49 MIN 52
MAKE-PATHNAME 49 MINUSP
MAKE-RANDOM-STATE 49 MINUSP 52
MAKE-SEQUENCE 49 MISMATCH
MAKE-STRING 49 MISMATCH 52
MAKE-STRING-INPUT-STREAM 49 MOD
MAKE-STRING-OUTPUT-STREAM 50 MOD 52
MAKE-SYMBOL 50 MODIFY
MAKE-SYNONYM-STREAM 50 DEFINE-MODIFY-MACRO 23
MAKE-TWO-WAY-STREAM 50 MODULES
*MAKE-CONSTANT 89 *MODULES* 52
*MAKE-SPECIAL 89 MOST
make-string-output-stream-from.. 89 MOST-NEGATIVE-DOUBLE-FLOAT 52
MAKUNBOUND MOST-NEGATIVE-FIXNUM 52
MAKUNBOUND 50 MOST-NEGATIVE-LONG-FLOAT 52
MAP MOST-NEGATIVE-SHORT-FLOAT 52
MAP 50 MOST-NEGATIVE-SINGLE-FLOAT 52
MAPC MOST-POSITIVE-DOUBLE-FLOAT 53
MAPC 50 MOST-POSITIVE-FIXNUM 53
MAPCAN MOST-POSITIVE-LONG-FLOAT 53
MAPCAN 50 MOST-POSITIVE-SHORT-FLOAT 53
MAPCAR MOST-POSITIVE-SINGLE-FLOAT 53
MAPCAR 50 MULTIPLE
MAPCON GET-SETF-METHOD-MULTIPLE-VALUE 39
MAPCON 50 MULTIPLE-VALUE-BIND 53
MAPHASH MULTIPLE-VALUE-CALL 53
MAPHASH 51 MULTIPLE-VALUE-LIST 53
MAPL MULTIPLE-VALUE-PROG1 53
MAPL 51 MULTIPLE-VALUE-SETQ 53
MAPLIST MULTIPLE-VALUES-LIMIT 53
MAPLIST 51 NAME
MASK CHAR-NAME 16
MASK-FIELD 51 LONG-SITE-NAME 47
MAX NAME-CHAR 53
MAX 51 PACKAGE-NAME 57
MAXIMUM PATHNAME-NAME 59
*IGNORE-MAXIMUM-PAGES* 40 SHORT-SITE-NAME 72
MAXIMUM-ALLOCATABLE-PAGES 51 SYMBOL-NAME 79
MAXIMUM-CONTIGUOUS-PAGES 51 COMPILED-FUNCTION-NAME 86
MAXPAGES NAMESTRING
*LISP-MAXPAGES* 89 DIRECTORY-NAMESTRING 28
MEMBER ENOUGH-NAMESTRING 30
MEMBER 51 FILE-NAMESTRING 33
MEMBER-IF 51 HOST-NAMESTRING 40
MEMBER-IF-NOT 51 NAMESTRING 54
MERGE PARSE-NAMESTRING 58
MERGE 51 NAND
MERGE-PATHNAMES 52 BIT-NAND 8
MESSAGE BOOLE-NAND 10
LAST-TERMINATION-MESSAGE 43 NANI
TERMINATION-MESSAGE 81 NANI 89
*GBC-MESSAGE* 88 NBUTLAST
*DEFAULT-MESSAGE-FILE* 91 NBUTLAST 54
KCL Dictionary Page 102
NCONC NREVERSE 55
NCONC 54 NSET
NEGATIVE NSET-DIFFERENCE 55
DOUBLE-FLOAT-NEGATIVE-EPSILON 29 NSET-EXCLUSIVE-OR 55
LEAST-NEGATIVE-DOUBLE-FLOAT 43 NSTRING
LEAST-NEGATIVE-LONG-FLOAT 43 NSTRING-CAPITALIZE 55
LEAST-NEGATIVE-SHORT-FLOAT 43 NSTRING-DOWNCASE 55
LEAST-NEGATIVE-SINGLE-FLOAT 43 NSTRING-UPCASE 55
LONG-FLOAT-NEGATIVE-EPSILON 47 NSUBLIS
MOST-NEGATIVE-DOUBLE-FLOAT 52 NSUBLIS 55
MOST-NEGATIVE-FIXNUM 52 NSUBST
MOST-NEGATIVE-LONG-FLOAT 52 NSUBST 55
MOST-NEGATIVE-SHORT-FLOAT 52 NSUBST-IF 55
MOST-NEGATIVE-SINGLE-FLOAT 52 NSUBST-IF-NOT 55
SHORT-FLOAT-NEGATIVE-EPSILON 72 NSUBSTITUTE
SINGLE-FLOAT-NEGATIVE-EPSILON 73 NSUBSTITUTE 56
NICKNAMES NSUBSTITUTE-IF 56
PACKAGE-NICKNAMES 58 NSUBSTITUTE-IF-NOT 56
NIL NTH
NIL 54 NTH 56
NINTERSECTION NTHCDR
NINTERSECTION 54 NTHCDR 56
NINTH NULL
NINTH 54 NULL 56
NO NUMBER
READ-CHAR-NO-HANG 65 NUMBER 56
YES-OR-NO-P 85 NUMBERP
NOR NUMBERP 56
BIT-NOR 8 NUMERATOR
BOOLE-NOR 10 NUMERATOR 56
NOT NUNION
ASSOC-IF-NOT 6 NUNION 57
BIT-NOT 8 OBJECT
CHAR-NOT-EQUAL 16 STRING-TO-OBJECT 90
CHAR-NOT-GREATERP 16 ODDP
CHAR-NOT-LESSP 16 ODDP 57
COUNT-IF-NOT 21 OF
DELETE-IF-NOT 27 TYPE-OF 82
FIND-IF-NOT 34 ON
MEMBER-IF-NOT 51 *BREAK-ON-WARNINGS* 10
NOT 54 *IGNORE-EOF-ON-TERMINAL-IO* 88
NSUBST-IF-NOT 55 OPEN
NSUBSTITUTE-IF-NOT 56 OPEN 57
POSITION-IF-NOT 60 WITH-OPEN-FILE 84
RASSOC-IF-NOT 64 WITH-OPEN-STREAM 84
REMOVE-IF-NOT 67 OR
STRING-NOT-EQUAL 76 NSET-EXCLUSIVE-OR 55
STRING-NOT-GREATERP 76 OR 57
STRING-NOT-LESSP 77 SET-EXCLUSIVE-OR 70
SUBST-IF-NOT 78 Y-OR-N-P 85
SUBSTITUTE-IF-NOT 79 YES-OR-NO-P 85
NOTANY ORC1
NOTANY 54 BIT-ORC1 8
NOTEVERY BOOLE-ORC1 10
NOTEVERY 54 ORC2
NOTIFY BIT-ORC2 8
*NOTIFY-GBC* 90 BOOLE-ORC2 10
NRECONC OUTPUT
NRECONC 54 CLEAR-OUTPUT 18
NREVERSE *ERROR-OUTPUT* 31
KCL Dictionary Page 103
FINISH-OUTPUT 34 MERGE-PATHNAMES 52
FORCE-OUTPUT 36 PEEK
GET-OUTPUT-STREAM-STRING 38 PEEK-CHAR 59
MAKE-STRING-OUTPUT-STREAM 50 PER
OUTPUT-STREAM-P 57 INTERNAL-TIME-UNITS-PER-SECOND 42
*STANDARD-OUTPUT* 75 PHASE
*TRACE-OUTPUT* 81 PHASE 59
WITH-OUTPUT-TO-STRING 84 PI
*INDENT-FORMATTED-OUTPUT* 88 PI 59
make-string-output-stream-from.. 89 PLIST
OUTPUT-STREAM-STRING 90 SYMBOL-PLIST 80
PACKAGE PLUSP
FIND-PACKAGE 34 PLUSP 59
IN-PACKAGE 41 POINTER
MAKE-PACKAGE 49 ARRAY-HAS-FILL-POINTER-P 5
PACKAGE 57 FILL-POINTER 33
*PACKAGE* 57 POP
PACKAGE-NAME 57 POP 60
PACKAGE-NICKNAMES 58 VECTOR-POP 83
PACKAGE-SHADOWING-SYMBOLS 58 POSITION
PACKAGE-USE-LIST 58 BYTE-POSITION 11
PACKAGE-USED-BY-LIST 58 FILE-POSITION 33
RENAME-PACKAGE 67 POSITION 60
SYMBOL-PACKAGE 79 POSITION-IF 60
UNUSE-PACKAGE 82 POSITION-IF-NOT 60
USE-PACKAGE 83 POSITIVE
PACKAGEP LEAST-POSITIVE-DOUBLE-FLOAT 43
PACKAGEP 58 LEAST-POSITIVE-LONG-FLOAT 43
PACKAGES LEAST-POSITIVE-SHORT-FLOAT 43
LIST-ALL-PACKAGES 45 LEAST-POSITIVE-SINGLE-FLOAT 44
PAGES MOST-POSITIVE-DOUBLE-FLOAT 53
ALLOCATE-CONTIGUOUS-PAGES 3 MOST-POSITIVE-FIXNUM 53
ALLOCATE-RELOCATABLE-PAGES 3 MOST-POSITIVE-LONG-FLOAT 53
ALLOCATED-CONTIGUOUS-PAGES 3 MOST-POSITIVE-SHORT-FLOAT 53
ALLOCATED-PAGES 3 MOST-POSITIVE-SINGLE-FLOAT 53
ALLOCATED-RELOCATABLE-PAGES 4 PPRINT
*IGNORE-MAXIMUM-PAGES* 40 PPRINT 60
MAXIMUM-ALLOCATABLE-PAGES 51 PRECISION
MAXIMUM-CONTIGUOUS-PAGES 51 FLOAT-PRECISION 35
PAIRLIS PRESERVING
PAIRLIS 58 READ-PRESERVING-WHITESPACE 65
PARAMETERS PRETTY
LAMBDA-PARAMETERS-LIMIT 42 *PRINT-PRETTY* 61
PARSE PRIN1
PARSE-INTEGER 58 PRIN1 60
PARSE-NAMESTRING 58 PRIN1-TO-STRING 60
PATHNAME PRINC
*DEFAULT-PATHNAME-DEFAULTS* 22 PRINC 60
MAKE-PATHNAME 49 PRINC-TO-STRING 61
PATHNAME 58 PRINT
PATHNAME-DEVICE 59 PRINT 61
PATHNAME-DIRECTORY 59 *PRINT-ARRAY* 61
PATHNAME-HOST 59 *PRINT-BASE* 61
PATHNAME-NAME 59 *PRINT-CASE* 61
PATHNAME-TYPE 59 *PRINT-CIRCLE* 61
PATHNAME-VERSION 59 *PRINT-ESCAPE* 61
USER-HOMEDIR-PATHNAME 83 *PRINT-GENSYM* 61
PATHNAMEP *PRINT-LENGTH* 61
PATHNAMEP 59 *PRINT-LEVEL* 61
PATHNAMES *PRINT-PRETTY* 61
KCL Dictionary Page 104
*PRINT-RADIX* 61 RATIONAL 64
PROBE RATIONALIZE
PROBE-FILE 62 RATIONALIZE 64
PROCESS RATIONALP
PROCESS 62 RATIONALP 64
PROCLAIM READ
PROCLAIM 62 READ 64
PROCLAMATION *READ-BASE* 64
PROCLAMATION 62 READ-BYTE 65
PROG READ-CHAR 65
PROG 62 READ-CHAR-NO-HANG 65
PROG* 62 *READ-DEFAULT-FLOAT-FORMAT* 65
PROG1 READ-DELIMITED-LIST 65
MULTIPLE-VALUE-PROG1 53 READ-FROM-STRING 65
PROG1 62 READ-LINE 65
PROG2 READ-PRESERVING-WHITESPACE 65
PROG2 62 *READ-SUPPRESS* 65
PROGN READTABLE
PROGN 62 COPY-READTABLE 20
PROGV READTABLE 66
PROGV 62 *READTABLE* 66
PROPERTIES READTABLEP
GET-PROPERTIES 38 READTABLEP 66
PROTECT REAL
UNWIND-PROTECT 83 GET-INTERNAL-REAL-TIME 38
PROVIDE REALPART
PROVIDE 63 REALPART 66
PSETF REDUCE
PSETF 63 REDUCE 66
PSETQ RELOCATABLE
PSETQ 63 ALLOCATE-RELOCATABLE-PAGES 3
PUSH ALLOCATED-RELOCATABLE-PAGES 4
PUSH 63 REM
VECTOR-PUSH 84 REM 66
VECTOR-PUSH-EXTEND 84 REMF
PUSHNEW REMF 66
PUSHNEW 63 REMHASH
QUERY REMHASH 66
*QUERY-IO* 63 REMOVE
QUOTE REMOVE 66
QUOTE 63 REMOVE-DUPLICATES 67
RADIX REMOVE-IF 67
FLOAT-RADIX 35 REMOVE-IF-NOT 67
*PRINT-RADIX* 61 REMPROP
RANDOM REMPROP 67
MAKE-RANDOM-STATE 49 RENAME
RANDOM 63 RENAME-FILE 67
RANDOM-STATE 63 RENAME-PACKAGE 67
*RANDOM-STATE* 63 REPLACE
RANDOM-STATE-P 64 REPLACE 67
RANK REQUIRE
ARRAY-RANK 5 REQUIRE 67
ARRAY-RANK-LIMIT 5 RESET
RASSOC RESET-GBC-COUNT 90
RASSOC 64 RESET-STACK-LIMITS 90
RASSOC-IF 64 REST
RASSOC-IF-NOT 64 REST 68
RATIO RETURN
RATIO 64 RETURN 68
RATIONAL RETURN-FROM 68
KCL Dictionary Page 105
REVAPPEND SHADOW
REVAPPEND 68 SHADOW 71
REVERSE SHADOWING
REVERSE 68 PACKAGE-SHADOWING-SYMBOLS 58
RIGHT SHADOWING-IMPORT 71
STRING-RIGHT-TRIM 77 SHIFTF
ROOM SHIFTF 71
ROOM 68 SHORT
ROTATEF LEAST-NEGATIVE-SHORT-FLOAT 43
ROTATEF 69 LEAST-POSITIVE-SHORT-FLOAT 43
ROUND MOST-NEGATIVE-SHORT-FLOAT 52
ROUND 69 MOST-POSITIVE-SHORT-FLOAT 53
ROW SHORT-FLOAT-EPSILON 71
ARRAY-ROW-MAJOR-INDEX 5 SHORT-FLOAT-NEGATIVE-EPSILON 72
RPLACA SHORT-SITE-NAME 72
RPLACA 69 SIGN
RPLACD FLOAT-SIGN 35
RPLACD 69 SIGNALS
RUN CATCH-BAD-SIGNALS 86
GET-INTERNAL-RUN-TIME 38 UNCATCH-BAD-SIGNALS 91
SAVE SIGNUM
SAVE 69 SIGNUM 72
SAVE-SYSTEM 90 SIMPLE
SBIT SIMPLE-ARRAY 72
SBIT 69 SIMPLE-BIT-VECTOR 72
SCALE SIMPLE-BIT-VECTOR-P 72
SCALE-FLOAT 69 SIMPLE-STRING 72
SCHAR SIMPLE-STRING-P 72
SCHAR 69 SIMPLE-VECTOR 72
SEARCH SIMPLE-VECTOR-P 72
SEARCH 69 SIN
SECOND SIN 72
INTERNAL-TIME-UNITS-PER-SECOND 42 SINGLE
SECOND 70 LEAST-NEGATIVE-SINGLE-FLOAT 43
SEQ LEAST-POSITIVE-SINGLE-FLOAT 44
COPY-SEQ 20 MOST-NEGATIVE-SINGLE-FLOAT 52
SEQUENCE MOST-POSITIVE-SINGLE-FLOAT 53
MAKE-SEQUENCE 49 SINGLE-FLOAT-EPSILON 72
SEQUENCE 70 SINGLE-FLOAT-NEGATIVE-EPSILON 73
SET SINH
BOOLE-SET 10 SINH 73
SET 70 SITE
SET-CHAR-BIT 70 LONG-SITE-NAME 47
SET-DIFFERENCE 70 SHORT-SITE-NAME 72
SET-DISPATCH-MACRO-CHARACTER 70 SIXTH
SET-EXCLUSIVE-OR 70 SIXTH 73
SET-MACRO-CHARACTER 70 SIZE
SET-SYNTAX-FROM-CHAR 70 ARRAY-TOTAL-SIZE 6
ERROR-SET 87 ARRAY-TOTAL-SIZE-LIMIT 6
SET-HOLE-SIZE 90 BYTE-SIZE 11
SETF GET-HOLE-SIZE 88
DEFINE-SETF-METHOD 24 SET-HOLE-SIZE 90
GET-SETF-METHOD 39 SLEEP
GET-SETF-METHOD-MULTIPLE-VALUE 39 SLEEP 73
SETF 71 SOFTWARE
SETQ SOFTWARE-TYPE 73
MULTIPLE-VALUE-SETQ 53 SOFTWARE-VERSION 73
SETQ 71 SOME
SEVENTH SOME 73
SEVENTH 71 SORT
KCL Dictionary Page 106
SORT 73 STRING-EQUAL 76
STABLE-SORT 74 STRING-GREATERP 76
SPECIAL STRING-LEFT-TRIM 76
SPECIAL-FORM-P 74 STRING-LESSP 76
*MAKE-SPECIAL 89 STRING-NOT-EQUAL 76
SPECIALP STRING-NOT-GREATERP 76
SPECIALP 90 STRING-NOT-LESSP 77
SQRT STRING-RIGHT-TRIM 77
SQRT 74 STRING-TRIM 77
STABLE STRING-UPCASE 77
STABLE-SORT 74 STRING/= 77
STACK STRING< 77
RESET-STACK-LIMITS 90 STRING<= 77
STANDARD STRING= 77
STANDARD-CHAR 74 STRING> 78
STANDARD-CHAR-P 74 STRING>= 78
*STANDARD-INPUT* 75 WITH-INPUT-FROM-STRING 84
*STANDARD-OUTPUT* 75 WITH-OUTPUT-TO-STRING 84
STATE WRITE-STRING 85
MAKE-RANDOM-STATE 49 WRITE-TO-STRING 85
RANDOM-STATE 63 GET-STRING-INPUT-STREAM-INDEX 88
*RANDOM-STATE* 63 make-string-output-stream-from.. 89
RANDOM-STATE-P 64 OUTPUT-STREAM-STRING 90
STEP STRING-CONCATENATE 90
STEP 75 STRING-TO-OBJECT 90
STREAM STRINGP
GET-OUTPUT-STREAM-STRING 38 STRINGP 78
INPUT-STREAM-P 41 STRUCTURE
MAKE-BROADCAST-STREAM 48 STRUCTURE 78
MAKE-CONCATENATED-STREAM 48 STRUCTUREP
MAKE-ECHO-STREAM 49 STRUCTUREP 91
MAKE-STRING-INPUT-STREAM 49 SUBLIS
MAKE-STRING-OUTPUT-STREAM 50 SUBLIS 78
MAKE-SYNONYM-STREAM 50 SUBSEQ
MAKE-TWO-WAY-STREAM 50 SUBSEQ 78
OUTPUT-STREAM-P 57 SUBSETP
STREAM 75 SUBSETP 78
STREAM-ELEMENT-TYPE 75 SUBST
WITH-OPEN-STREAM 84 SUBST 78
COPY-STREAM 87 SUBST-IF 78
GET-STRING-INPUT-STREAM-INDEX 88 SUBST-IF-NOT 78
make-string-output-stream-from.. 89 SUBSTITUTE
OUTPUT-STREAM-STRING 90 SUBSTITUTE 79
STREAMP SUBSTITUTE-IF 79
STREAMP 75 SUBSTITUTE-IF-NOT 79
STRING SUBTYPEP
GET-OUTPUT-STREAM-STRING 38 SUBTYPEP 79
MAKE-STRING 49 SUPER
MAKE-STRING-INPUT-STREAM 49 CHAR-SUPER-BIT 16
MAKE-STRING-OUTPUT-STREAM 50 SUPPRESS
PRIN1-TO-STRING 60 *READ-SUPPRESS* 65
PRINC-TO-STRING 61 SVREF
READ-FROM-STRING 65 SVREF 79
SIMPLE-STRING 72 SXHASH
SIMPLE-STRING-P 72 SXHASH 79
STRING 75 SYMBOL
STRING-CAPITALIZE 75 COPY-SYMBOL 21
STRING-CHAR 76 FIND-SYMBOL 34
STRING-CHAR-P 76 MAKE-SYMBOL 50
STRING-DOWNCASE 76 SYMBOL-FUNCTION 79
KCL Dictionary Page 107
SYMBOL-NAME 79 TIME 81
SYMBOL-PACKAGE 79 *DEFAULT-TIME-ZONE* 87
SYMBOL-PLIST 80 TO
SYMBOL-VALUE 80 PRIN1-TO-STRING 60
SYMBOLP PRINC-TO-STRING 61
SYMBOLP 80 WITH-OUTPUT-TO-STRING 84
SYMBOLS WRITE-TO-STRING 85
DO-ALL-SYMBOLS 28 STRING-TO-OBJECT 90
DO-EXTERNAL-SYMBOLS 28 TOP
DO-SYMBOLS 29 TOP-LEVEL 91
FIND-ALL-SYMBOLS 34 TOTAL
PACKAGE-SHADOWING-SYMBOLS 58 ARRAY-TOTAL-SIZE 6
SYNONYM ARRAY-TOTAL-SIZE-LIMIT 6
MAKE-SYNONYM-STREAM 50 TRACE
SYNTAX TRACE 81
SET-SYNTAX-FROM-CHAR 70 *TRACE-OUTPUT* 81
SYSTEM TREE
SYSTEM 80 COPY-TREE 21
INIT-SYSTEM 89 TREE-EQUAL 81
SAVE-SYSTEM 90 TRIM
*SYSTEM-DIRECTORY* 91 STRING-LEFT-TRIM 76
TABLE STRING-RIGHT-TRIM 77
HASH-TABLE 39 STRING-TRIM 77
HASH-TABLE-COUNT 39 TRUENAME
HASH-TABLE-P 40 TRUENAME 81
MAKE-HASH-TABLE 49 TRUNCATE
TAGBODY TRUNCATE 81
TAGBODY 80 TWO
TAILP MAKE-TWO-WAY-STREAM 50
TAILP 80 TYPE
TAN ARRAY-ELEMENT-TYPE 5
TAN 80 CHECK-TYPE 17
TANH LISP-IMPLEMENTATION-TYPE 44
TANH 80 MACHINE-TYPE 47
TENTH PATHNAME-TYPE 59
TENTH 80 SOFTWARE-TYPE 73
TERMINAL STREAM-ELEMENT-TYPE 75
*TERMINAL-IO* 80 TYPE-OF 82
*IGNORE-EOF-ON-TERMINAL-IO* 88 TYPECASE
TERMINATION TYPECASE 82
LAST-TERMINATION-MESSAGE 43 TYPEP
TERMINATION-MESSAGE 81 TYPEP 82
TERPRI UNCATCH
TERPRI 81 UNCATCH-BAD-SIGNALS 91
TEST UNEXPORT
LDB-TEST 43 UNEXPORT 82
THE UNINTERN
THE 81 UNINTERN 82
THIRD UNION
THIRD 81 UNION 82
THROW UNITS
THROW 81 INTERNAL-TIME-UNITS-PER-SECOND 42
TIME UNIVERSAL
DECODE-UNIVERSAL-TIME 22 DECODE-UNIVERSAL-TIME 22
ENCODE-UNIVERSAL-TIME 30 ENCODE-UNIVERSAL-TIME 30
GET-DECODED-TIME 38 GET-UNIVERSAL-TIME 39
GET-INTERNAL-REAL-TIME 38 UNIVERSAL-ERROR-HANDLER 91
GET-INTERNAL-RUN-TIME 38 UNLESS
GET-UNIVERSAL-TIME 39 UNLESS 82
INTERNAL-TIME-UNITS-PER-SECOND 42 UNREAD
KCL Dictionary Page 108
UNREAD-CHAR 82 WARN
UNTRACE WARN 84
UNTRACE 82 WARNINGS
UNUSE *BREAK-ON-WARNINGS* 10
UNUSE-PACKAGE 82 WAY
UNWIND MAKE-TWO-WAY-STREAM 50
UNWIND-PROTECT 83 WHEN
UPCASE EVAL-WHEN 31
CHAR-UPCASE 16 *EVAL-WHEN-COMPILE* 31
NSTRING-UPCASE 55 WHEN 84
STRING-UPCASE 77 WHITESPACE
UPPER READ-PRESERVING-WHITESPACE 65
UPPER-CASE-P 83 WITH
USE WITH-INPUT-FROM-STRING 84
PACKAGE-USE-LIST 58 WITH-OPEN-FILE 84
USE-PACKAGE 83 WITH-OPEN-STREAM 84
USED WITH-OUTPUT-TO-STRING 84
PACKAGE-USED-BY-LIST 58 WRITE
USER FILE-WRITE-DATE 33
USER-HOMEDIR-PATHNAME 83 WRITE 85
VAL WRITE-BYTE 85
BDS-VAL 86 WRITE-CHAR 85
VALUE WRITE-LINE 85
GET-SETF-METHOD-MULTIPLE-VALUE 39 WRITE-STRING 85
MULTIPLE-VALUE-BIND 53 WRITE-TO-STRING 85
MULTIPLE-VALUE-CALL 53 XOR
MULTIPLE-VALUE-LIST 53 BIT-XOR 8
MULTIPLE-VALUE-PROG1 53 BOOLE-XOR 10
MULTIPLE-VALUE-SETQ 53 YES
SYMBOL-VALUE 80 YES-OR-NO-P 85
VALUES ZEROP
MULTIPLE-VALUES-LIMIT 53 ZEROP 86
VALUES 83 ZONE
VALUES-LIST 83 *DEFAULT-TIME-ZONE* 87
VAR
BDS-VAR 86
VECTOR
BIT-VECTOR 8
BIT-VECTOR-P 8
SIMPLE-BIT-VECTOR 72
SIMPLE-BIT-VECTOR-P 72
SIMPLE-VECTOR 72
SIMPLE-VECTOR-P 72
VECTOR 83
VECTOR-POP 83
VECTOR-PUSH 84
VECTOR-PUSH-EXTEND 84
VECTORP
VECTORP 84
VERBOSE
*LOAD-VERBOSE* 45
VERSION
LISP-IMPLEMENTATION-VERSION 44
MACHINE-VERSION 47
PATHNAME-VERSION 59
SOFTWARE-VERSION 73
VS
FRS-VS 87
IHS-VS 88
VS 91